Built with Alectryon, running Coq+SerAPI v8.16.0+0.16.0. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus. On Mac, use instead of Ctrl.
From Coq Require Import ssreflect ssrfun ssrbool.

From Ltac2 Require Import Ltac2 Control.

From Coq Require Import Ensembles Bool String.
From Coq.Logic Require Import FunctionalExtensionality Eqdep_dec.
From Equations Require Import Equations.

Require Import Coq.Program.Tactics.

From MatchingLogic Require Import
    Utils.extralibrary
    Logic
    DerivedOperators_Syntax
    ProofMode_base
    ProofInfo
    BasicProofSystemLemmas
.

New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
New coercion path [Is_true] : bool >-> Sortclass is ambiguous with existing [is_true] : bool >-> Sortclass. [ambiguous-paths,typechecker]
From MatchingLogic.Utils Require Import stdpp_ext. Import extralibrary. Import MatchingLogic.Logic.Notations MatchingLogic.DerivedOperators_Syntax.Notations . Set Default Proof Mode "Classic". Open Scope string_scope. Open Scope list_scope. Open Scope ml_scope.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo

Γ Ⱶ l₁ ++ (name ∶ g) :: l₂-------------------------------------- g using info
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo

Γ Ⱶ l₁ ++ (name ∶ g) :: l₂-------------------------------------- g using info
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (patterns_of (l₁ ++ (name ∶ g) :: l₂))

Γ Ⱶ l₁ ++ (name ∶ g) :: l₂-------------------------------------- g using info
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (patterns_of (l₁ ++ (name ∶ g) :: l₂))

Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g) :: l₂)) using info
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (patterns_of (l₁ ++ (name ∶ g) :: l₂))

Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g) :: l₂)) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

Γ ⊢i foldr patt_imp g (map nh_patt (l₁ ++ (name ∶ g) :: l₂)) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((name ∶ g) :: l₂)) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

well_formed (nh_patt (name ∶ g))
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

well_formed (nh_patt (name ∶ g))
exact wfg.
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

Pattern.wf (map nh_patt l₁)
abstract ( pose proof (wfl₁ := wf_take (length (patterns_of l₁)) _ wfl₁gl₂); rewrite map_app in wfl₁; rewrite take_app in wfl₁; exact wfl₁ ).
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: hypotheses
name: string
g: Pattern
info: ProofInfo
wfg: well_formed g
wfl₁gl₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g) :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
abstract ( pose proof (wfgl₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gl₂); rewrite map_app in wfgl₂; rewrite drop_app in wfgl₂; unfold Pattern.wf in wfgl₂; simpl in wfgl₂; apply andb_prop in wfgl₂; destruct wfgl₂ as [_ wfl₂]; exact wfl₂ ). } Defined. Tactic Notation "mlExactn" constr(n) := _ensureProofMode; _mlReshapeHypsByIdx n; apply MLGoal_exactn.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo

find_hyp name l = Some (idx, name ∶ g) → Γ Ⱶ l-------------------------------------- g using info
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo

find_hyp name l = Some (idx, name ∶ g) → Γ Ⱶ l-------------------------------------- g using info
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound: find_hyp name l = Some (idx, name ∶ g)

Γ Ⱶ l-------------------------------------- g using info
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound: l !! idx = Some (name ∶ g) ∧ has_name name (name ∶ g) ∧ ( (j : nat) (y : named_hypothesis), l !! j = Some y → j < idx → ¬ has_name name y)

Γ Ⱶ l-------------------------------------- g using info
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: (j : nat) (y : named_hypothesis), l !! j = Some y → j < idx → ¬ has_name name y

Γ Ⱶ l-------------------------------------- g using info
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: (j : nat) (y : named_hypothesis), l !! j = Some y → j < idx → ¬ has_name name y

l !! idx = Some (name ∶ g)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: (j : nat) (y : named_hypothesis), l !! j = Some y → j < idx → ¬ has_name name y
Γ Ⱶ take idx l ++ (name ∶ g) :: drop (S idx) l-------------------------------------- g using info
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: (j : nat) (y : named_hypothesis), l !! j = Some y → j < idx → ¬ has_name name y

l !! idx = Some (name ∶ g)
exact Hfound1.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g: Pattern
idx: nat
info: ProofInfo
Hfound1: l !! idx = Some (name ∶ g)
Hfound2: has_name name (name ∶ g)
Hfound3: (j : nat) (y : named_hypothesis), l !! j = Some y → j < idx → ¬ has_name name y

Γ Ⱶ take idx l ++ (name ∶ g) :: drop (S idx) l-------------------------------------- g using info
apply MLGoal_exactn. Defined. Tactic Notation "mlExact" constr(name') := _ensureProofMode; eapply MLGoal_exact with (name := name'); simpl; apply f_equal; reflexivity .
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a = true → well_formed b = true → well_formed c = true → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a = true → well_formed b = true → well_formed c = true → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

well_formed (a ---> b ---> c ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true
Γ Ⱶ a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

well_formed (a ---> b ---> c ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

Γ Ⱶ a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

Γ Ⱶ "H1" ∶ a, -------------------------------------- b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

Γ Ⱶ "H1" ∶ a, "H2" ∶ b, -------------------------------------- c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfc: well_formed c = true

Γ Ⱶ "H1" ∶ a, "H2" ∶ b, "H3" ∶ c, -------------------------------------- b using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo

Γ ⊢i g ---> g' using i → Γ Ⱶ l-------------------------------------- g using i → Γ Ⱶ l-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo

Γ ⊢i g ---> g' using i → Γ Ⱶ l-------------------------------------- g using i → Γ Ⱶ l-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: Γ Ⱶ l-------------------------------------- g using i

Γ Ⱶ l-------------------------------------- g' using i
(*mlExtractWF wfl wfgp.*)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- g' using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g' using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- g' using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- g' using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g' using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- g' using i )
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i

well_formed g' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed (g ---> g')

Γ ⊢i foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g

Γ ⊢i foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed ?g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g'
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i ?g ---> g' using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g'
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Γ ⊢i g ---> g' using i
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g'
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
g, g': Pattern
i: ProofInfo
Hgg': Γ ⊢i g ---> g' using i
Hlg: well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfl: Pattern.wf (patterns_of l)
wfimp: well_formed g
Pattern.wf (patterns_of l)
all: assumption. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
apply modus_ponens; assumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning

Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning

Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
H2: Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning
Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning

Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning
apply P2; wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
H2: Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning

Γ ⊢i (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
H2: Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning

Γ ⊢i ?ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
H2: Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning
Γ ⊢i ?ϕ₁ ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
H1: Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
H2: Γ ⊢i (a ---> (a ---> b) ---> b) ---> (a ---> a ---> b) ---> a ---> b using BasicReasoning

Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
apply H1. Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
apply reorder; wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning

Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning

Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
apply H1.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning

well_formed (a ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed ((a ---> b ---> c) ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Γ ⊢i ?B ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> ?B using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning

well_formed (a ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed ((b ---> a ---> c) ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed ((a ---> b ---> c) ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i (a ---> b ---> c) ---> b ---> a ---> c using BasicReasoning
H2: Γ ⊢i ((b ---> a ---> c) ---> a ---> c) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
apply syllogism; wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
apply prf_contraction; wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]

Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]

Γ ⊢i foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c] using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]

Pattern.wf [a ---> b; b ---> a ---> c]
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
well_formed ?g
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
well_formed (a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
Γ ⊢i ?g ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
Γ ⊢i foldr patt_imp ?g [a ---> b; b ---> a ---> c] using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]

Pattern.wf [a ---> b; b ---> a ---> c]
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
well_formed (a ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
well_formed (a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]

Pattern.wf [a ---> b; b ---> a ---> c]
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
well_formed (a ---> a ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H3: Γ ⊢i (a ---> b) ---> (b ---> a ---> c) ---> a ---> a ---> c using BasicReasoning
H4: Γ ⊢i (a ---> a ---> c) ---> a ---> c using BasicReasoning
Hiter: ((a ---> b) ---> (b ---> a ---> c) ---> a ---> c) = foldr patt_imp (a ---> c) [a ---> b; b ---> a ---> c]
well_formed (a ---> c)
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b using i → Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b using i → Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i

Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i
Γ ⊢i ?ϕ₁ ---> (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i

Γ ⊢i ?ϕ₁ ---> (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i

Γ ⊢i ?ϕ₁ ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
apply prf_weaken_conclusion_under_implication; wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b using i

Γ ⊢i a ---> b using i
exact H. Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b using i → Γ ⊢i a ---> b ---> c using i → Γ ⊢i a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b using i → Γ ⊢i a ---> b ---> c using i → Γ ⊢i a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

Γ ⊢i a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

Γ ⊢i ?ϕ₁ using i
apply H2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

Γ ⊢i (a ---> b ---> c) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed c
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
Γ ⊢i a ---> b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

Γ ⊢i a ---> b using i
apply H1.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i

well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H1: Γ ⊢i a ---> b using i
H2: Γ ⊢i a ---> b ---> c using i
well_formed c
all: wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern

Pattern.wf l → well_formed g → well_formed g' → Γ ⊢i ((g ---> g') ---> foldr patt_imp g l) ---> (g ---> g') ---> foldr patt_imp g' l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern

Pattern.wf l → well_formed g → well_formed g' → Γ ⊢i ((g ---> g') ---> foldr patt_imp g l) ---> (g ---> g') ---> foldr patt_imp g' l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'

Γ ⊢i ((g ---> g') ---> foldr patt_imp g l) ---> (g ---> g') ---> foldr patt_imp g' l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H1: Γ ⊢i (g ---> g') ---> foldr patt_imp g l ---> foldr patt_imp g' l using BasicReasoning

Γ ⊢i ((g ---> g') ---> foldr patt_imp g l) ---> (g ---> g') ---> foldr patt_imp g' l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
H1: Γ ⊢i a ---> foldr patt_imp g l ---> foldr patt_imp g' l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g l) ---> a ---> foldr patt_imp g' l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
H1: Γ ⊢i a ---> b ---> foldr patt_imp g' l using BasicReasoning

Γ ⊢i (a ---> b) ---> a ---> foldr patt_imp g' l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed (a ---> b)
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed (a ---> b ---> c)
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b) ---> (a ---> b ---> c) ---> a ---> c using BasicReasoning
well_formed (a ---> c)
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using BasicReasoning

Γ ⊢i (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using BasicReasoning

Γ ⊢i ?ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using BasicReasoning
Γ ⊢i ?ϕ₁ ---> (a ---> b) ---> a ---> c using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
a: Pattern
Heqa: a = (g ---> g')
b: Pattern
Heqb: b = foldr patt_imp g l
c: Pattern
Heqc: c = foldr patt_imp g' l
H1: Γ ⊢i a ---> b ---> c using BasicReasoning
H: well_formed a
H0: well_formed b
H2: well_formed c
H2': Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using BasicReasoning

Γ ⊢i a ---> b ---> c using BasicReasoning
apply H1. Defined.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed g' → Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i → Γ ⊢i (g ---> g') ---> foldr patt_imp g' l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed g' → Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i → Γ ⊢i (g ---> g') ---> foldr patt_imp g' l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i

Γ ⊢i (g ---> g') ---> foldr patt_imp g' l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Γ ⊢i ?ϕ₁ ---> (g ---> g') ---> foldr patt_imp g' l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i

Γ ⊢i ?ϕ₁ ---> (g ---> g') ---> foldr patt_imp g' l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i

Γ ⊢i ?ϕ₁ ---> (g ---> g') ---> foldr patt_imp g' l using BasicReasoning
apply prf_weaken_conclusion_iter_under_implication; wf_auto2.
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i

Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, g': Pattern
i: ProofInfo
wfl: Pattern.wf l
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i

Γ ⊢i (g ---> g') ---> foldr patt_imp g l using i
exact H. } Defined.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo

Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i → Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo

Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i → Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i

Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed (mlConclusion (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i ))) → mlTheory (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i )) (patterns_of (mlHypotheses (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i ))) using mlInfo (Γ Ⱶ (name ∶ g ---> g') :: l-------------------------------------- g' using i )
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i

well_formed g' → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l, Htmp: Pattern.wf ((g ---> g') :: patterns_of l)

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Htmp: foldr andb true (map well_formed ((g ---> g') :: patterns_of l))

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Htmp: well_formed (g ---> g') && foldr andb true (map well_formed (patterns_of l))

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
Htmp: well_formed (g ---> g') = true ∧ foldr andb true (map well_formed (patterns_of l)) = true

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
wfgg': well_formed (g ---> g') = true
wfl: foldr andb true (map well_formed (patterns_of l)) = true

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf ((g ---> g') :: patterns_of l) → Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
wfgg': well_formed g
wfl: foldr andb true (map well_formed (patterns_of l)) = true

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: Γ ⊢i (g ---> g') ---> foldr patt_imp g (patterns_of l) using i
wfg': well_formed g'
wfgg'l: Pattern.wf ((g ---> g') :: patterns_of l)
wfgg': well_formed g
wfl: foldr andb true (map well_formed (patterns_of l)) = true

Γ ⊢i (g ---> g') ---> foldr patt_imp g' (patterns_of l) using i
apply prf_weaken_conclusion_iter_under_implication_meta; assumption. Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern

Pattern.wf l₁ → Pattern.wf l₂ → well_formed g → well_formed g' → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern

Pattern.wf l₁ → Pattern.wf l₂ → well_formed g → well_formed g' → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'

Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf []
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'

Γ ⊢i ((g ---> g') ---> foldr patt_imp g l₂) ---> (g ---> g') ---> foldr patt_imp g' l₂ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf (a :: l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf []
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'

Γ ⊢i ((g ---> g') ---> foldr patt_imp g l₂) ---> (g ---> g') ---> foldr patt_imp g' l₂ using BasicReasoning
apply prf_weaken_conclusion_iter_under_implication; auto.
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf (a :: l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: Pattern.wf (a :: l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: foldr andb true (map well_formed (a :: l₁))
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: well_formed a && foldr andb true (map well_formed l₁)
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfl₁: well_formed a = true ∧ foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Pattern.wf l₁ → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

Γ ⊢i (a ---> foldr patt_imp g (l₁ ++ (g ---> g') :: l₂)) ---> a ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed (foldr patt_imp g (l₁ ++ (g ---> g') :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed (foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)

well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed (foldr patt_imp g (l₁ ++ (g ---> g') :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₁, l₂: list Pattern
g, g': Pattern
wfa: well_formed a = true
wfl₁: foldr andb true (map well_formed l₁) = true
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
IHl₁: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
wfal₁: Pattern.wf (a :: l₁)
well_formed (foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂))
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo

Pattern.wf l₁ → Pattern.wf l₂ → well_formed g → well_formed g' → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i → Γ ⊢i foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo

Pattern.wf l₁ → Pattern.wf l₂ → well_formed g → well_formed g' → Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i → Γ ⊢i foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i

Γ ⊢i foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i

Γ ⊢i ?ϕ₁ using i
apply H.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i

Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i

Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
g, g': Pattern
i: ProofInfo
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfg: well_formed g
wfg': well_formed g'
H: Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) using i

Γ ⊢i foldr patt_imp g (l₁ ++ (g ---> g') :: l₂) ---> foldr patt_imp g' (l₁ ++ (g ---> g') :: l₂) using BasicReasoning
apply prf_weaken_conclusion_iter_under_implication_iter; wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo

Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i → Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo

Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i → Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo

(well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g using i )) → well_formed (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i ))) → mlTheory (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i ))) using mlInfo (Γ Ⱶ l₁ ++ (name ∶ g ---> g') :: l₂-------------------------------------- g' using i )
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo

(well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i) → well_formed g' → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g' (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g' (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt (l₁ ++ (name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g' (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g' (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g' (map nh_patt (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g' (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Pattern.wf (map nh_patt l₁)
abstract (pose proof (wfl₁ := wf_take (length (patterns_of l₁)) _ wfl₁gg'l₂); simpl in wfl₁; rewrite take_app in wfl₁; exact wfl₁).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
abstract ( pose proof (wfgg'l₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gg'l₂); rewrite drop_app in wfgg'l₂; pose proof (Htmp := wfgg'l₂); unfold Pattern.wf in Htmp; simpl in Htmp; apply andb_prop in Htmp; destruct Htmp as [wfgg' wfl₂]; exact wfl₂ ).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

well_formed g
abstract( pose proof (wfgg'l₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gg'l₂); rewrite drop_app in wfgg'l₂; pose proof (Htmp := wfgg'l₂); unfold Pattern.wf in Htmp; simpl in Htmp; apply andb_prop in Htmp; destruct Htmp as [wfgg' wfl₂]; pose proof (wfg := well_formed_imp_proj1 _ _ wfgg'); exact wfg ).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

well_formed g'
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

well_formed g'
exact wfg'.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
H: well_formed g → Pattern.wf (map nh_patt (l₁ ++ (name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt (l₁ ++ (name ∶ g ---> g') :: l₂)) using i
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))

Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) using i

Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ (g ---> g') :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) using i

well_formed g
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) using i
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) using i

well_formed g
abstract( pose proof (wfgg'l₂ := wf_drop (length (patterns_of l₁)) _ wfl₁gg'l₂); rewrite drop_app in wfgg'l₂; pose proof (Htmp := wfgg'l₂); unfold Pattern.wf in Htmp; simpl in Htmp; apply andb_prop in Htmp; destruct Htmp as [wfgg' wfl₂]; pose proof (wfg := well_formed_imp_proj1 _ _ wfgg'); exact wfg ).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
name: string
g, g': Pattern
i: ProofInfo
wfg': well_formed g'
wfl₁gg'l₂: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
H: well_formed g → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂)) using i

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((name ∶ g ---> g') :: l₂))
exact wfl₁gg'l₂. Defined. Tactic Notation "mlApplyn" constr(n) := _ensureProofMode; _mlReshapeHypsByIdx n; apply MLGoal_weakenConclusion; _mlReshapeHypsBack. Tactic Notation "mlApply" constr(name') := _ensureProofMode; _mlReshapeHypsByName name'; apply MLGoal_weakenConclusion; _mlReshapeHypsBack.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (a ---> (a ---> b) ---> b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (a ---> (a ---> b) ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ a ---> (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ a, -------------------------------------- (a ---> b) ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ a, "H2" ∶ a ---> b, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ a, "H2" ∶ a ---> b, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i a ---> (a ---> b) ---> a using BasicReasoning
apply P1; wf_auto2. Defined.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern

well_formed p → well_formed q → well_formed r → well_formed s → Γ ⊢i (p ---> q) ---> (r ---> s) ---> p or r ---> q or s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern

well_formed p → well_formed q → well_formed r → well_formed s → Γ ⊢i (p ---> q) ---> (r ---> s) ---> p or r ---> q or s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ ⊢i (p ---> q) ---> (r ---> s) ---> p or r ---> q or s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ ⊢i (p ---> q) ---> (r ---> s) ---> (! p ---> r) ---> ! q ---> s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

well_formed ((p ---> q) ---> (r ---> s) ---> (! p ---> r) ---> ! q ---> s)
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s
Γ Ⱶ (p ---> q) ---> (r ---> s) ---> (! p ---> r) ---> ! q ---> s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

well_formed ((p ---> q) ---> (r ---> s) ---> (! p ---> r) ---> ! q ---> s)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ (p ---> q) ---> (r ---> s) ---> (! p ---> r) ---> ! q ---> s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, -------------------------------------- (r ---> s) ---> (! p ---> r) ---> ! q ---> s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, -------------------------------------- (! p ---> r) ---> ! q ---> s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, -------------------------------------- ! q ---> s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, "H3" ∶ ! q, -------------------------------------- s using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, "H3" ∶ ! q, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, "H3" ∶ ! q, -------------------------------------- ! p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, "H3" ∶ ! q, "H4" ∶ p, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, "H3" ∶ q ---> ⊥, "H4" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r, s: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
wfs: well_formed s

Γ Ⱶ "H0" ∶ p ---> q, "H1" ∶ r ---> s, "H2" ∶ ! p ---> r, "H3" ∶ q ---> ⊥, "H4" ∶ p, -------------------------------------- p using BasicReasoning
mlExact "H4". Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c using i → Γ ⊢i (a ---> b) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c using i → Γ ⊢i (a ---> b) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i (a ---> b) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ ⊢i ?ϕ₁ ---> (a ---> b) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i ?ϕ₁ using i
apply H.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i (a ---> b ---> c) ---> (a ---> b) ---> a ---> c using BasicReasoning
apply P2; wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfh: well_formed h

Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
g, h: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfh: well_formed h

Γ ⊢i h ---> (h ---> g) ---> g using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
g, h: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfh: well_formed h

Γ ⊢i h ---> (h ---> g) ---> g using BasicReasoning
apply modus_ponens; auto.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfl: well_formed a = true ∧ (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
assumption.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
apply H1.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
apply P2; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning

well_formed (a ---> foldr patt_imp h l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
well_formed ((a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i ?B ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> ?B using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning

well_formed (a ---> foldr patt_imp h l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
well_formed (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
well_formed ((a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning

well_formed (a ---> foldr patt_imp h l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
well_formed (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl: (fix fold_right (l : list bool) : bool := match l with | [] => true | b :: t => b && fold_right t end) ((fix map (l : list Pattern) : list bool := match l with | [] => [] | a :: t => well_formed a :: map t end) l) = true
wfg: well_formed g
wfh: well_formed h
IHl: Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
wfal: Pattern.wf (a :: l)
H1: Γ ⊢i a ---> foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l) ---> a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l) ---> (a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l using BasicReasoning
well_formed ((a ---> foldr patt_imp g (l ++ [h])) ---> a ---> foldr patt_imp g l)
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l using i → Γ ⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l using i → Γ ⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Γ ⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Γ ⊢i ?ϕ₁ using i
apply H.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Γ ⊢i foldr patt_imp h l ---> foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i

Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
well_formed h
all: wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l using i → Γ ⊢i foldr patt_imp g (l ++ [h]) using i → Γ ⊢i foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l using i → Γ ⊢i foldr patt_imp g (l ++ [h]) using i → Γ ⊢i foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Γ ⊢i foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Γ ⊢i ?ϕ₁ using i
apply H0.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Γ ⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Γ ⊢i foldr patt_imp g (l ++ [h]) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed h
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
Γ ⊢i foldr patt_imp h l using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i

Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l using i
H0: Γ ⊢i foldr patt_imp g (l ++ [h]) using i
well_formed h
all: wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo

well_formed h → Γ Ⱶ l-------------------------------------- h using i → Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i → Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo

well_formed h → Γ Ⱶ l-------------------------------------- h using i → Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i → Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: Γ Ⱶ l-------------------------------------- h using i
H2: Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i

Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- h using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- h using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- h using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- h using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- h using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- h using i )
H2: well_formed (mlConclusion (Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l ++ (name ∶ h, )-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- g using i )
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i

well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed ?h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?h (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l ++ [?h]) using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (patterns_of l ++ [h]) using i
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
H2: well_formed g → Pattern.wf (patterns_of (l ++ (name ∶ h, ))) → Γ ⊢i foldr patt_imp g (patterns_of (l ++ (name ∶ h, ))) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g → Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, )) → Γ ⊢i foldr patt_imp g (map nh_patt l ++ map nh_patt (name ∶ h, )) using i
well_formed g
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g → Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, )) → Γ ⊢i foldr patt_imp g (map nh_patt l ++ map nh_patt (name ∶ h, )) using i
Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, ))
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g → Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, )) → Γ ⊢i foldr patt_imp g (map nh_patt l ++ map nh_patt (name ∶ h, )) using i

Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, ))
Σ: Signature
Γ: Theory
l: hypotheses
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp h (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
H2: well_formed g → Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, )) → Γ ⊢i foldr patt_imp g (map nh_patt l ++ map nh_patt (name ∶ h, )) using i

Pattern.wf (map nh_patt l ++ map nh_patt (name ∶ h, ))
abstract ( unfold Pattern.wf; rewrite map_app; rewrite foldr_app; simpl; rewrite wfh; simpl; exact wfl ). } Defined.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf l1
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h

Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h

Γ ⊢i h ---> (h ---> foldr patt_imp g l2) ---> foldr patt_imp g l2 using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h

Γ ⊢i h ---> (h ---> foldr patt_imp g l2) ---> foldr patt_imp g l2 using BasicReasoning
apply modus_ponens; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: foldr andb true (map well_formed (a :: l1))
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a && foldr andb true (map well_formed l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a = true ∧ foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)

Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
assumption.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
exact H1.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
apply P2; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp h l1) ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

well_formed (a ---> foldr patt_imp h l1)
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
well_formed ((a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i ?B ---> (a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> ?B using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

well_formed (a ---> foldr patt_imp h l1)
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
well_formed (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
well_formed ((a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning

well_formed (a ---> foldr patt_imp h l1)
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
well_formed (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
wfal1: Pattern.wf (a :: l1)
H1: Γ ⊢i a ---> foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H2: Γ ⊢i (a ---> foldr patt_imp h l1) ---> a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
H3: Γ ⊢i (a ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2)) ---> (a ---> foldr patt_imp g (l1 ++ [h] ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
well_formed ((a ---> foldr patt_imp g (l1 ++ h :: l2)) ---> a ---> foldr patt_imp g (l1 ++ l2))
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l1 using i → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l1 using i → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i

Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i

Γ ⊢i ?ϕ₁ using i
apply H.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i

Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i

Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i

Γ ⊢i foldr patt_imp h l1 ---> foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using BasicReasoning
apply prf_add_lemma_under_implication_generalized; wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l1 using i → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp h l1 using i → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Γ ⊢i ?ϕ₁ using i
apply H0.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) ---> foldr patt_imp g (l1 ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Pattern.wf l1
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Pattern.wf l2
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed h
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Γ ⊢i foldr patt_imp h l1 using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i

Pattern.wf l1
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Pattern.wf l2
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
WFl1: Pattern.wf l1
WFl2: Pattern.wf l2
WFg: well_formed g
WGh: well_formed h
H: Γ ⊢i foldr patt_imp h l1 using i
H0: Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
well_formed h
all: wf_auto2. } Defined.
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo

well_formed h → Γ Ⱶ l1-------------------------------------- h using i → Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i → Γ Ⱶ l1 ++ l2-------------------------------------- g using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo

well_formed h → Γ Ⱶ l1-------------------------------------- h using i → Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i → Γ Ⱶ l1 ++ l2-------------------------------------- g using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: Γ Ⱶ l1-------------------------------------- h using i
H2: Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i

Γ Ⱶ l1 ++ l2-------------------------------------- g using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed (mlConclusion (Γ Ⱶ l1-------------------------------------- h using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l1-------------------------------------- h using i ))) → mlTheory (Γ Ⱶ l1-------------------------------------- h using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l1-------------------------------------- h using i )) (patterns_of (mlHypotheses (Γ Ⱶ l1-------------------------------------- h using i ))) using mlInfo (Γ Ⱶ l1-------------------------------------- h using i )
H2: well_formed (mlConclusion (Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l1 ++ (name ∶ h, ) ++ l2-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ l1 ++ l2-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ l2-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l1 ++ l2-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l1 ++ l2-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ l2-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l1 ++ l2-------------------------------------- g using i )
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i

well_formed g → Pattern.wf (patterns_of (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ l2)) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ l2)) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed ?h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ ⊢i foldr patt_imp ?h (map nh_patt l1) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ [?h] ++ map nh_patt l2) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ [h] ++ map nh_patt l2) using i
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
well_formed h
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i
well_formed g
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l1)
abstract ( apply (wf_take (length (patterns_of l1))) in wfl1l2; unfold patterns_of in wfl1l2; rewrite map_app in wfl1l2; rewrite take_app in wfl1l2; exact wfl1l2 ).
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l2)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (map nh_patt l2)
abstract ( apply (wf_drop (length (patterns_of l1))) in wfl1l2; unfold patterns_of in wfl1l2; rewrite map_app in wfl1l2; rewrite drop_app in wfl1l2; exact wfl1l2 ).
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (patterns_of l1)
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
H2: well_formed g → Pattern.wf (patterns_of (l1 ++ (name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ (name ∶ h) :: l2)) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))

Pattern.wf (patterns_of l1)
abstract ( apply (wf_take (length (patterns_of l1))) in wfl1l2; unfold patterns_of in wfl1l2; rewrite map_app in wfl1l2; rewrite take_app in wfl1l2; exact wfl1l2 ).
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i

Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
Σ: Signature
Γ: Theory
l1: hypotheses
l2: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
wfh: well_formed h
H1: well_formed h → Pattern.wf (patterns_of l1) → Γ ⊢i foldr patt_imp h (patterns_of l1) using i
wfg: well_formed g
wfl1l2: Pattern.wf (patterns_of (l1 ++ l2))
H2: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2)) using i

Pattern.wf (map nh_patt l1 ++ map nh_patt ((name ∶ h) :: l2))
abstract( pose proof (wfl1 := wf_take (length (patterns_of l1)) _ wfl1l2); unfold patterns_of in wfl1; rewrite map_app in wfl1; rewrite take_app in wfl1; pose proof (wfl2 := wf_drop (length (patterns_of l1)) _ wfl1l2); unfold patterns_of in wfl2; rewrite map_app in wfl2; rewrite drop_app in wfl2; unfold Pattern.wf; rewrite map_app; rewrite foldr_app; simpl; rewrite wfh; unfold Pattern.wf in wfl2; rewrite wfl2; simpl; exact wfl1 ). } Defined. Tactic Notation "_mlAssert_nocheck" "(" constr(name) ":" constr(t) ")" := match goal with | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) => let Hwf := fresh "Hwf" in assert (Hwf : well_formed t); [idtac| let H := fresh "H" in assert (H : @mkMLGoal Sgm Ctx l t i); [ | (eapply (@mlGoal_assert Sgm Ctx l name g t i Hwf H); rewrite [_ ++ _]/=; clear H)] ] end. (* TODO: make this bind tigther. *) Tactic Notation "mlAssert" "(" constr(name) ":" constr(t) ")" := _ensureProofMode; _failIfUsed name; _mlAssert_nocheck (name : t) . Tactic Notation "mlAssert" "(" constr (t) ")" := _ensureProofMode; let hyps := _getHypNames in let name := eval lazy in (fresh hyps) in mlAssert (name : (t)).
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i a ---> a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i a ---> a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ ⊢i a ---> a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (a ---> a ---> a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ a ---> a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (a ---> a ---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ a ---> a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H0" ∶ a, -------------------------------------- a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed a
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ "H0" ∶ a, "H1" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed a
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a
Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, -------------------------------------- a using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a

well_formed a
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, "0" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf: well_formed a

well_formed a
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a
Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, "0" ∶ a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, -------------------------------------- a using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
a: Pattern
wfa, Hwf, Hwf0: well_formed a

Γ Ⱶ "H0" ∶ a, "H1" ∶ a, "H2" ∶ a, "0" ∶ a, -------------------------------------- a using BasicReasoning
mlExact "H2". Qed. Ltac _getGoalProofInfo := lazymatch goal with | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) => i end. Ltac _getGoalTheory := lazymatch goal with | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) => Ctx end. Tactic Notation "mlAssert" "(" constr(name) ":" constr(t) ")" "using" "first" constr(n) := _ensureProofMode; _failIfUsed name; lazymatch goal with | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) => let l1 := fresh "l1" in let l2 := fresh "l2" in let Heql1 := fresh "Heql1" in let Heql2 := fresh "Heql2" in remember (take n l) as l1 eqn:Heql1 in |-; remember (drop n l) as l2 eqn:Heql2 in |-; simpl in Heql1; simpl in Heql2; eapply cast_proof_ml_hyps; [( rewrite -[l](take_drop n); reflexivity )|]; let Hwf := fresh "Hwf" in assert (Hwf : well_formed t); [idtac| let H := fresh "H" in assert (H : @mkMLGoal Sgm Ctx l1 t i) ; [ (eapply cast_proof_ml_hyps; [(rewrite Heql1; reflexivity)|]); clear l1 l2 Heql1 Heql2 | apply (cast_proof_ml_hyps _ _ _ (f_equal patterns_of Heql1)) in H; eapply (@mlGoal_assert_generalized Sgm Ctx (take n l) (drop n l) name g t i Hwf H); rewrite [_ ++ _]/=; clear l1 l2 Heql1 Heql2 H] ] end. Tactic Notation "mlAssert" "(" constr(t) ")" "using" "first" constr(n) := _ensureProofMode; let hyps := _getHypNames in let name := eval cbv in (fresh hyps) in mlAssert (name : t) using first n.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern

well_formed a = true → well_formed b = true → well_formed p = true → well_formed q = true → Γ ⊢i a ---> p and q ---> b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern

well_formed a = true → well_formed b = true → well_formed p = true → well_formed q = true → Γ ⊢i a ---> p and q ---> b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

Γ ⊢i a ---> p and q ---> b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

well_formed (a ---> p and q ---> b ---> ! ! q)
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Γ Ⱶ a ---> p and q ---> b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

well_formed (a ---> p and q ---> b ---> ! ! q)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

Γ Ⱶ a ---> p and q ---> b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

Γ Ⱶ "H0" ∶ a, -------------------------------------- p and q ---> b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- b ---> ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a, "H1" ∶ p and q, )
l2: list named_hypothesis
Heql2: l2 = ("H2" ∶ b, )

well_formed p
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "H4" ∶ p, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a, "H1" ∶ p and q, )
l2: list named_hypothesis
Heql2: l2 = ("H2" ∶ b, )

well_formed p
wf_auto2.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "H4" ∶ p, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
admit.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "H4" ∶ p, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a, "H1" ∶ p and q, )
l2: list named_hypothesis
Heql2: l2 = ("H4" ∶ p, "H2" ∶ b, )

well_formed p
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "0" ∶ p, "H4" ∶ p, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf: well_formed p
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a, "H1" ∶ p and q, )
l2: list named_hypothesis
Heql2: l2 = ("H4" ∶ p, "H2" ∶ b, )

well_formed p
wf_auto2.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p
Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "0" ∶ p, "H4" ∶ p, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
admit.
Σ: Signature
Γ: Theory
p, q, a, b: Pattern
wfa: well_formed a = true
wfb: well_formed b = true
wfp: well_formed p = true
wfq: well_formed q = true
Hwf, Hwf0: well_formed p

Γ Ⱶ "H0" ∶ a, "H1" ∶ p and q, "0" ∶ p, "H4" ∶ p, "H2" ∶ b, -------------------------------------- ! ! q using BasicReasoning
Abort.
Σ: Signature
Γ: Theory
A: Pattern

well_formed A → Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern

well_formed A → Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed (! A)
wf_auto2.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning

Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning

Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning

Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning

well_formed (! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning

well_formed (! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
well_formed A
all: wf_auto2.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

Γ ⊢i (! A ---> A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

well_formed ?A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i (! A ---> A) ---> ?A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i ?A ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i ?B ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> ?B using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
apply H1.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning

well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! A ---> ! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
H1: Γ ⊢i (! A ---> ! ! A) ---> ! ! A using BasicReasoning
H2: Γ ⊢i (! A ---> A) ---> ! A ---> ! ! A using BasicReasoning
well_formed A
all: wf_auto2. Defined.
Σ: Signature
p: Pattern

p = foldr patt_imp p []
Σ: Signature
p: Pattern

p = foldr patt_imp p []
reflexivity. Defined.
Σ: Signature
p, q: Pattern
l: list Pattern

foldr patt_imp (p ---> q) l = foldr patt_imp q (l ++ [p])
Σ: Signature
p, q: Pattern
l: list Pattern

foldr patt_imp (p ---> q) l = foldr patt_imp q (l ++ [p])
Σ: Signature
p, q: Pattern
l: list Pattern

foldr patt_imp (p ---> q) l = foldr patt_imp (foldr patt_imp q [p]) l
reflexivity. Defined.
Σ: Signature
Γ: Theory
p, q, r: Pattern

well_formed p → well_formed q → well_formed r → Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern

well_formed p → well_formed q → well_formed r → Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning

Γ ⊢i r or r ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning

Γ ⊢i r or r ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning

Γ ⊢i (! r ---> r) ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning

well_formed r
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning
= ((p ---> r) ---> (q ---> r) ---> p or q ---> r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning

= ((p ---> r) ---> (q ---> r) ---> p or q ---> r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning

= foldr patt_imp ((p ---> r) ---> (q ---> r) ---> p or q ---> r or r) []
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H1: Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r or r using BasicReasoning
H: Γ ⊢i r or r ---> r using BasicReasoning

= foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
reflexivity.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp ?g' ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
Pattern.wf ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
well_formed (r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
well_formed ?g'
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
Γ ⊢i r or r ---> ?g' using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp r ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
Pattern.wf ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
well_formed (r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
well_formed r
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp r ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
apply H1.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning

Pattern.wf ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q])
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
well_formed (r or r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
H: Γ ⊢i r or r ---> r using BasicReasoning
H1: Γ ⊢i foldr patt_imp (r or r) ((([] ++ [p ---> r]) ++ [q ---> r]) ++ [p or q]) using BasicReasoning
well_formed r
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed r → Γ ⊢i p ---> r using i → Γ ⊢i (q ---> r) ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed r → Γ ⊢i p ---> r using i → Γ ⊢i (q ---> r) ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i

Γ ⊢i (q ---> r) ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
Γ ⊢i ?ϕ₁ ---> (q ---> r) ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i

well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
well_formed r
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed r → Γ ⊢i p ---> r using i → Γ ⊢i q ---> r using i → Γ ⊢i p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed r → Γ ⊢i p ---> r using i → Γ ⊢i q ---> r using i → Γ ⊢i p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i

Γ ⊢i p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i ?ϕ₁ ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i

Γ ⊢i (q ---> r) ---> p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i

well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed r
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
Γ ⊢i p ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i

well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
well_formed r
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed r → Γ ⊢i p ---> r using i → Γ ⊢i q ---> r using i → Γ ⊢i p or q using i → Γ ⊢i r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed r → Γ ⊢i p ---> r using i → Γ ⊢i q ---> r using i → Γ ⊢i p or q using i → Γ ⊢i r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i

Γ ⊢i r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i ?ϕ₁ ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i

Γ ⊢i p or q ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i

well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
well_formed r
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i p ---> r using i
Σ: Signature
Γ: Theory
p, q, r: Pattern
i: ProofInfo
WFp: well_formed p
WHq: well_formed q
WFr: well_formed r
H: Γ ⊢i p ---> r using i
H0: Γ ⊢i q ---> r using i
H1: Γ ⊢i p or q using i
Γ ⊢i q ---> r using i
all: assumption. Defined.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo

Pattern.wf l → well_formed a → well_formed g → Γ ⊢i a using i → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo

Pattern.wf l → well_formed a → well_formed g → Γ ⊢i a using i → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf l
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i

Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i

Γ ⊢i foldr patt_imp g [a] ---> foldr patt_imp g [] using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf (a0 :: l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i

Γ ⊢i foldr patt_imp g [a] ---> foldr patt_imp g [] using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i

Γ ⊢i (a ---> g) ---> g using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning

Γ ⊢i (a ---> g) ---> g using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
Γ ⊢i ?ϕ₁ ---> (a ---> g) ---> g using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning

Γ ⊢i a ---> (a ---> g) ---> g using i
Σ: Signature
Γ: Theory
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf []
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
H: Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning

Γ ⊢i a ---> (a ---> g) ---> g using BasicReasoning
apply H.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf (a0 :: l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: Pattern.wf (a0 :: l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: foldr andb true (map well_formed (a0 :: l))
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: well_formed a0 && foldr andb true (map well_formed l)
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfl: well_formed a0 = true ∧ foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i foldr patt_imp g (a :: a0 :: l) ---> foldr patt_imp g (a0 :: l) using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
(* < change a0 and a in the LHS > *)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
apply reorder; wf_auto2.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning

((a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l) =
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
Γ ⊢i using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning

((a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l) =
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning

((a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l) = foldr patt_imp []
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning

((a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l) = foldr patt_imp ?q ([] ++ [?p])
reflexivity.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: (h h' g : Pattern) (i : ProofInfo), Pattern.wf [] → Pattern.wf [] → well_formed h → well_formed h' → well_formed g → Γ ⊢i h' ---> h using i → Γ ⊢i foldr patt_imp g ([] ++ [h]) using i → Γ ⊢i foldr patt_imp g ([] ++ [h']) using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: (h h' g : Pattern) (i : ProofInfo), Pattern.wf [] → Pattern.wf [] → well_formed h → well_formed h' → well_formed g → Γ ⊢i h' ---> h using i → Γ ⊢i h ---> g using i → Γ ⊢i h' ---> g using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: (h h' g : Pattern) (i : ProofInfo), Pattern.wf [] → Pattern.wf [] → well_formed h → well_formed h' → well_formed g → Γ ⊢i h' ---> h using i → Γ ⊢i h ---> g using i → Γ ⊢i h' ---> g using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: (g0 : Pattern) (i : ProofInfo), Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed g0 → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> g0 using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> g0 using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Pattern.wf []
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Pattern.wf []
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a ---> a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
apply H.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using BasicReasoning
H0: i : ProofInfo, Pattern.wf [] → Pattern.wf [] → well_formed (a0 ---> a ---> foldr patt_imp g l) → well_formed (a ---> a0 ---> foldr patt_imp g l) → well_formed (a0 ---> foldr patt_imp g l) → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> a ---> foldr patt_imp g l using i → Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i → Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
(* </change a0 and a > *)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
Γ ⊢i ?ϕ₁ ---> (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i ?ϕ₁ ---> (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i ?ϕ₁ ---> (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using BasicReasoning
apply modus_ponens; wf_auto2.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)

Γ ⊢i a using i
apply Ha.
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

well_formed ?A
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> ?A using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i ?A ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

well_formed (a ---> a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> a ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
well_formed (a0 ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i
Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a ---> a0 ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
a0: Pattern
l: list Pattern
a, g: Pattern
i: ProofInfo
wfa0: well_formed a0 = true
wfl: foldr andb true (map well_formed l) = true
wfa: well_formed a
wfg: well_formed g
Ha: Γ ⊢i a using i
IHl: Γ ⊢i (a ---> foldr patt_imp g l) ---> foldr patt_imp g l using i
wfa0l: Pattern.wf (a0 :: l)
H: Γ ⊢i (a ---> a0 ---> foldr patt_imp g l) ---> a0 ---> foldr patt_imp g l using i

Γ ⊢i (a0 ---> a ---> foldr patt_imp g l) ---> a ---> a0 ---> foldr patt_imp g l using BasicReasoning
apply reorder; wf_auto2. Defined.
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo

Pattern.wf l → well_formed a → well_formed g → Γ ⊢i a using i → Γ ⊢i foldr patt_imp g (a :: l) using i → Γ ⊢i foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo

Pattern.wf l → well_formed a → well_formed g → Γ ⊢i a using i → Γ ⊢i foldr patt_imp g (a :: l) using i → Γ ⊢i foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i

Γ ⊢i foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i

Γ ⊢i foldr patt_imp g (a :: l) ---> foldr patt_imp g l using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i

Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed a
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed g
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
Γ ⊢i a using i
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i

Pattern.wf l
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed a
Σ: Signature
Γ: Theory
l: list Pattern
a, g: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFa: well_formed a
WFg: well_formed g
H: Γ ⊢i a using i
H0: Γ ⊢i foldr patt_imp g (a :: l) using i
well_formed g
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo

Γ ⊢i h using i → Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i → Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo

Γ ⊢i h using i → Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i → Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i

Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed (mlConclusion (Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ (name ∶ h) :: l-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- g using i )
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i

well_formed g → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i h using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp g (h :: patterns_of l) using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed h
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Γ ⊢i h using i
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
well_formed g
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (h :: patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

well_formed h
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)
Pattern.wf (h :: patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

well_formed h
abstract (pose (tmp := proj1_sig H); apply proved_impl_wf in tmp; exact tmp).
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (h :: patterns_of l)
Σ: Signature
Γ: Theory
l: list named_hypothesis
name: string
g, h: Pattern
i: ProofInfo
H: Γ ⊢i h using i
H0: well_formed g → Pattern.wf (h :: patterns_of l) → Γ ⊢i h ---> foldr patt_imp g (patterns_of l) using i
wfg: well_formed g
wfl: Pattern.wf (patterns_of l)

Pattern.wf (h :: patterns_of l)
abstract ( unfold Pattern.wf; simpl; pose (tmp := proj1_sig H); apply proved_impl_wf in tmp; rewrite tmp; simpl; exact wfl ). } Defined. Tactic Notation "mlAdd" constr(n) "as" constr(name') := _ensureProofMode; _failIfUsed name'; match goal with | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) => apply (@MLGoal_add Sgm Ctx l name' g _ i n) end. Tactic Notation "mlAdd" constr(n) := _ensureProofMode; let hyps := _getHypNames in let name := eval cbv in (fresh hyps) in mlAdd n as name.
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i h ---> g using i → Γ ⊢i h using i → Γ ⊢i g using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed h → Γ ⊢i h ---> g using i → Γ ⊢i h using i → Γ ⊢i g using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i

Γ ⊢i g using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i

Γ Ⱶ "H0" ∶ h, -------------------------------------- g using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i

Γ Ⱶ "0" ∶ h ---> g, "H0" ∶ h, -------------------------------------- g using i
Σ: Signature
Γ: Theory
l: list Pattern
g, h: Pattern
i: ProofInfo
WFl: Pattern.wf l
WFg: well_formed g
WFh: well_formed h
H: Γ ⊢i h ---> g using i
H0: Γ ⊢i h using i

Γ Ⱶ "0" ∶ h ---> g, "H0" ∶ h, -------------------------------------- h using i
mlExact "H0". Defined.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf l1
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h

Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h

Γ ⊢i foldr patt_imp g l2 ---> h ---> foldr patt_imp g l2 using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf []
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h

Γ ⊢i foldr patt_imp g l2 ---> h ---> foldr patt_imp g l2 using BasicReasoning
apply P1; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: Pattern.wf (a :: l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: foldr andb true (map well_formed (a :: l1))
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a && foldr andb true (map well_formed l1)
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfl1: well_formed a = true ∧ foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Pattern.wf l1 → Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
H1: Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

well_formed (a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ h :: l2))
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Γ Ⱶ a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

well_formed (a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ h :: l2))
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ Ⱶ a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ Ⱶ "H0" ∶ foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2), -------------------------------------- a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ Ⱶ "H0" ∶ foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2), "H1" ∶ a, -------------------------------------- foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
mlExact "H0".
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
H1: Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp g (l1 ++ l2)) ---> a ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l1, l2: list Pattern
g, h: Pattern
wfa: well_formed a = true
wfl1: foldr andb true (map well_formed l1) = true
wfl2: Pattern.wf l2
wfg: well_formed g
wfh: well_formed h
IHl1: Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
H1: Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning

Γ ⊢i a ---> foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ h :: l2) using BasicReasoning
apply H1. Defined.
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo

Pattern.wf l1 → Pattern.wf l2 → well_formed g → well_formed h → Γ ⊢i foldr patt_imp g (l1 ++ l2) using i → Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i

Γ ⊢i foldr patt_imp g (l1 ++ [h] ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l1 ++ [h] ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i

Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using i
Σ: Signature
Γ: Theory
l1, l2: list Pattern
g, h: Pattern
i: ProofInfo
H: Pattern.wf l1
H0: Pattern.wf l2
H1: well_formed g
H2: well_formed h
H3: Γ ⊢i foldr patt_imp g (l1 ++ l2) using i

Γ ⊢i foldr patt_imp g (l1 ++ l2) ---> foldr patt_imp g (l1 ++ [h] ++ l2) using BasicReasoning
apply prf_clear_hyp; wf_auto2. Defined.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo

Γ Ⱶ l1 ++ l2-------------------------------------- g using i → Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo

Γ Ⱶ l1 ++ l2-------------------------------------- g using i → Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: Γ Ⱶ l1 ++ l2-------------------------------------- g using i

Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed (mlConclusion (Γ Ⱶ l1 ++ l2-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ l2-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l1 ++ l2-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l1 ++ l2-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ l2-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l1 ++ l2-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l1 ++ h :: l2-------------------------------------- g using i )
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (patterns_of (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ l2)) using i

well_formed g → Pattern.wf (patterns_of (l1 ++ h :: l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ h :: l2)) using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (patterns_of (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (patterns_of (l1 ++ h :: l2))

Γ ⊢i foldr patt_imp g (patterns_of (l1 ++ h :: l2)) using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt (l1 ++ h :: l2))

Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ h :: l2)) using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt (l1 ++ h :: l2))

Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt (h :: l2)) using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt (h :: l2)) using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2) using i
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i
well_formed g
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Pattern.wf (map nh_patt l1)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1)

Pattern.wf (map nh_patt l1)
exact wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l2)

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l2)
exact wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i
Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)

well_formed (nh_patt h)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
H1: well_formed g → Pattern.wf (map nh_patt (l1 ++ l2)) → Γ ⊢i foldr patt_imp g (map nh_patt (l1 ++ l2)) using i
wfg: well_formed g
wfl1hl2: well_formed (nh_patt h)

well_formed (nh_patt h)
exact wfl1hl2.
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i

Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ nh_patt h :: map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i

Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
Σ: Signature
Γ: Theory
l1, l2: list named_hypothesis
g: Pattern
h: named_hypothesis
i: ProofInfo
wfg: well_formed g
wfl1hl2: Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
H1: well_formed g → Pattern.wf (map nh_patt l1 ++ map nh_patt l2) → Γ ⊢i foldr patt_imp g (map nh_patt l1 ++ map nh_patt l2) using i

Pattern.wf (map nh_patt l1 ++ map nh_patt l2)
exact wfl1hl2. } Defined. Tactic Notation "mlClear" constr(name) := _ensureProofMode; _mlReshapeHypsByName name; apply mlGoal_clear_hyp; _mlReshapeHypsBack.
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

well_formed (a ---> b ---> c ---> b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

well_formed (a ---> b ---> c ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ a ---> b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, -------------------------------------- b ---> c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, -------------------------------------- c ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, "H2" ∶ c, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H1" ∶ b, -------------------------------------- b using BasicReasoning
mlExact "H1". Defined.
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i p ---> q ---> (p ---> ! q) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i p ---> q ---> (p ---> ! q) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p ---> q ---> (p ---> ! q) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

(p ---> q ---> (p ---> ! q) ---> ⊥) =
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

(p ---> q ---> (p ---> ! q) ---> ⊥) =
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

foldr patt_imp (p ---> q ---> (p ---> ! q) ---> ⊥) [] =
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

foldr patt_imp ⊥ ((([] ++ [p]) ++ [q]) ++ [p ---> ! q]) =
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

foldr patt_imp ⊥ [p; q; p ---> ! q] =
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

foldr patt_imp ⊥ ([p] ++ [q; p ---> ! q] ++ []) =
reflexivity.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i foldr patt_imp ⊥ ([p] ++ [q; p ---> ! q] ++ []) using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i foldr patt_imp ⊥ ([p] ++ [p ---> ! q; q] ++ []) using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p ---> (p ---> ! q) ---> q ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p ---> (p ---> ! q) ---> ! q using BasicReasoning
apply modus_ponens; wf_auto2. Defined.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern

Pattern.wf l → well_formed g → well_formed x → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern

Pattern.wf l → well_formed g → well_formed x → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
wfl: Pattern.wf l
wfg: well_formed g
wfx: well_formed x

Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x

Γ ⊢i foldr patt_imp g [x] ---> foldr patt_imp g ([] ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x

Γ ⊢i foldr patt_imp g [x] ---> foldr patt_imp g ([] ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x

Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfl: Pattern.wf []
wfg: well_formed g
wfx: well_formed x

well_formed (x ---> g)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: Pattern.wf (a :: l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: well_formed a && foldr andb true (map well_formed l)
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: well_formed a = true ∧ foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp g (x :: a :: l) ---> foldr patt_imp g ((a :: l) ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (x ---> a ---> foldr patt_imp g l) ---> a ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (x ---> a ---> foldr patt_imp g l) ---> a ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

((x ---> a ---> foldr patt_imp g l) ---> a ---> foldr patt_imp g (l ++ [x])) =
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

((x ---> a ---> foldr patt_imp g l) ---> a ---> foldr patt_imp g (l ++ [x])) =
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

foldr patt_imp ((x ---> a ---> foldr patt_imp g l) ---> a ---> foldr patt_imp g (l ++ [x])) [] =
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

foldr patt_imp (foldr patt_imp g (l ++ [x])) (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) =
reflexivity.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp (foldr patt_imp g (l ++ [x])) (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Pattern.wf (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a])
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed ?g
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (foldr patt_imp g (l ++ [x]))
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i ?g ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i foldr patt_imp ?g (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i ?g ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
apply IHl.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Pattern.wf (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a])
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (x ---> foldr patt_imp g l)
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
well_formed (foldr patt_imp g (l ++ [x]))
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i foldr patt_imp (x ---> foldr patt_imp g l) (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp (x ---> foldr patt_imp g l) (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

foldr patt_imp (x ---> foldr patt_imp g l) (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) =
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

foldr patt_imp (x ---> foldr patt_imp g l) (([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) =
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

foldr patt_imp (foldr patt_imp g l) ((([] ++ [x ---> a ---> foldr patt_imp g l]) ++ [a]) ++ [x]) =
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

foldr patt_imp (foldr patt_imp g l) ([x ---> a ---> foldr patt_imp g l] ++ [a; x] ++ []) =
reflexivity.
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfg: well_formed g
wfx: well_formed x
IHl: Γ ⊢i (x ---> foldr patt_imp g l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp (foldr patt_imp g l) ([x ---> a ---> foldr patt_imp g l] ++ [a; x] ++ []) using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true (map (λ phi : Pattern, [&& well_formed_positive phi, well_formed_closed_mu_aux phi 0 & well_formed_closed_ex_aux phi 0]) l) = true
H4: lwf_cmu 0 l = true
H3: well_formed_positive g = true
H14: well_formed_closed_ex_aux g 0 = true
H13: well_formed_closed_mu_aux g 0 = true
H5: well_formed_positive x = true
H12: well_formed_closed_ex_aux x 0 = true
H11: well_formed_closed_mu_aux x 0 = true
H7, H2: true = true
H6: well_formed_positive a = true
H10: well_formed_closed_ex_aux a 0 = true
H9: well_formed_closed_mu_aux a 0 = true
H1: lwf_positive l = true
H0: lwf_cex 0 l = true
H15: true = true

Γ ⊢i (x ---> a ---> foldr patt_imp g l) ---> x ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true (map (λ phi : Pattern, [&& well_formed_positive phi, well_formed_closed_mu_aux phi 0 & well_formed_closed_ex_aux phi 0]) l) = true
H4: lwf_cmu 0 l = true
H3: well_formed_positive g = true
H14: well_formed_closed_ex_aux g 0 = true
H13: well_formed_closed_mu_aux g 0 = true
H5: well_formed_positive x = true
H12: well_formed_closed_ex_aux x 0 = true
H11: well_formed_closed_mu_aux x 0 = true
H7, H2: true = true
H6: well_formed_positive a = true
H10: well_formed_closed_ex_aux a 0 = true
H9: well_formed_closed_mu_aux a 0 = true
H1: lwf_positive l = true
H0: lwf_cex 0 l = true
H15: true = true

Γ ⊢i (x ---> a ---> foldr patt_imp g l) ---> x ---> a ---> foldr patt_imp g l using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
l: list Pattern
wfl: foldr andb true (map (λ phi : Pattern, [&& well_formed_positive phi, well_formed_closed_mu_aux phi 0 & well_formed_closed_ex_aux phi 0]) l) = true
H4: lwf_cmu 0 l = true
H3: well_formed_positive g = true
H14: well_formed_closed_ex_aux g 0 = true
H13: well_formed_closed_mu_aux g 0 = true
H5: well_formed_positive x = true
H12: well_formed_closed_ex_aux x 0 = true
H11: well_formed_closed_mu_aux x 0 = true
H7, H2: true = true
H6: well_formed_positive a = true
H10: well_formed_closed_ex_aux a 0 = true
H9: well_formed_closed_mu_aux a 0 = true
H1: lwf_positive l = true
H0: lwf_cex 0 l = true
H15: true = true

well_formed (x ---> a ---> foldr patt_imp g l)
wf_auto2. Defined.
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed x → Γ ⊢i foldr patt_imp g (x :: l) using i → Γ ⊢i foldr patt_imp g (l ++ [x]) using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo

Pattern.wf l → well_formed g → well_formed x → Γ ⊢i foldr patt_imp g (x :: l) using i → Γ ⊢i foldr patt_imp g (l ++ [x]) using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i

Γ ⊢i foldr patt_imp g (l ++ [x]) using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (l ++ [x]) using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i

Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using i
Σ: Signature
Γ: Theory
g, x: Pattern
l: list Pattern
i: ProofInfo
WFl: Pattern.wf l
WFG: well_formed g
WFx: well_formed x
H: Γ ⊢i foldr patt_imp g (x :: l) using i

Γ ⊢i foldr patt_imp g (x :: l) ---> foldr patt_imp g (l ++ [x]) using BasicReasoning
apply reorder_last_to_head; wf_auto2. Defined. (* Iterated modus ponens. For l = [x₁, ..., xₙ], it says that Γ ⊢i ((x₁ -> ... -> xₙ -> (x₁ -> ... -> xₙ -> r)) -> r) *)
Σ: Signature
Γ: Theory
l: list Pattern
r: Pattern

Pattern.wf l → well_formed r → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
r: Pattern

Pattern.wf l → well_formed r → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
r: Pattern
wfl: Pattern.wf l
wfr: well_formed r

Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r

Γ ⊢i foldr patt_imp r ([] ++ [foldr patt_imp r []]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: Pattern.wf (a :: l)
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r

Γ ⊢i foldr patt_imp r ([] ++ [foldr patt_imp r []]) using BasicReasoning
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r

Γ ⊢i r ---> r using BasicReasoning
Σ: Signature
Γ: Theory
r: Pattern
wfl: Pattern.wf []
wfr: well_formed r

well_formed r
exact wfr.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: Pattern.wf (a :: l)
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: Pattern.wf (a :: l)
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: well_formed a && foldr andb true (map well_formed l)
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfl: well_formed a = true ∧ foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [foldr patt_imp r (a :: l)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

(a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

(a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

(a ---> foldr patt_imp (foldr patt_imp r [a ---> foldr patt_imp r l]) l) =
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

(a ---> foldr patt_imp ((a ---> foldr patt_imp r l) ---> r) l) =
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

(a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

(a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l])) =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i using BasicReasoning

Γ ⊢i a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)
= foldr patt_imp r (l ++ [foldr patt_imp r l])
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

= foldr patt_imp r (l ++ [foldr patt_imp r l])
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [foldr patt_imp r l]) using BasicReasoning
wfal: Pattern.wf (a :: l)

= foldr patt_imp (foldr patt_imp r [foldr patt_imp r l]) l
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r [foldr patt_imp r l]) l using BasicReasoning

Γ ⊢i a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning

Γ ⊢i a ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning

well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
well_formed ?B
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
well_formed (foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
Γ ⊢i ?B ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
Γ ⊢i a ---> ?B using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning

Γ ⊢i ?B ---> foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]) using BasicReasoning
apply reorder_last_to_head; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning

well_formed a
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
well_formed (foldr patt_imp r ((a ---> foldr patt_imp r l) :: l))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
well_formed (foldr patt_imp r (l ++ [a ---> foldr patt_imp r l]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning
Γ ⊢i a ---> foldr patt_imp r ((a ---> foldr patt_imp r l) :: l) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning

Γ ⊢i a ---> foldr patt_imp r ((a ---> foldr patt_imp r l) :: l) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfr: well_formed r
wfal: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (foldr patt_imp r l ---> r) l using BasicReasoning

Γ ⊢i a ---> (a ---> foldr patt_imp r l) ---> foldr patt_imp r l using BasicReasoning
apply modus_ponens; wf_auto2. Defined.
Σ: Signature
Γ: Theory
p, q, r: Pattern

well_formed p → well_formed q → well_formed r → Γ ⊢i (p and q ---> r) ---> p ---> q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern

well_formed p → well_formed q → well_formed r → Γ ⊢i (p and q ---> r) ---> p ---> q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i (p and q ---> r) ---> p ---> q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed ((p and q ---> r) ---> p ---> q ---> r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ (p and q ---> r) ---> p ---> q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed ((p and q ---> r) ---> p ---> q ---> r)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ (p and q ---> r) ---> p ---> q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ p and q ---> r, -------------------------------------- p ---> q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ p and q ---> r, "H2" ∶ p, -------------------------------------- q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ p and q ---> r, "H2" ∶ p, "H3" ∶ q, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, -------------------------------------- ! (! p or ! q) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! p or ! q, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed (! ! p)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, -------------------------------------- ! ! p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed (! ! p)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, -------------------------------------- ! ! p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, -------------------------------------- ! ! p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

Γ Ⱶ "H6" ∶ p ---> ! ! p, "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, -------------------------------------- ! ! p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

Γ Ⱶ "H6" ∶ p ---> ! ! p, "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, -------------------------------------- p using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

well_formed (! q)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, "H6" ∶ ! q, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)

well_formed (! q)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)
Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, "H6" ∶ ! q, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ! q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, -------------------------------------- ! ! p using BasicReasoning
mlExact "H5".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, "H6" ∶ ! q, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed (! ! p)
Hwf0: well_formed (! q)

Γ Ⱶ "H0" ∶ ! (! p or ! q) ---> r, "H2" ∶ p, "H3" ∶ q, "H4" ∶ ! ! p ---> ! q, "H5" ∶ ! ! p, "H6" ∶ q ---> ⊥, -------------------------------------- q using BasicReasoning
mlExact "H3". Defined.
Σ: Signature
Γ: Theory
p, q, r: Pattern

well_formed p → well_formed q → well_formed r → Γ ⊢i (p ---> q ---> r) ---> p and q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern

well_formed p → well_formed q → well_formed r → Γ ⊢i (p ---> q ---> r) ---> p and q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i (p ---> q ---> r) ---> p and q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed ((p ---> q ---> r) ---> p and q ---> r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Γ Ⱶ (p ---> q ---> r) ---> p and q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed ((p ---> q ---> r) ---> p and q ---> r)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ (p ---> q ---> r) ---> p and q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ p ---> q ---> r, -------------------------------------- p and q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed p
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

well_formed p
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

Γ Ⱶ "H2" ∶ p and q ---> p, "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

Γ Ⱶ "H2" ∶ p and q ---> p, "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, -------------------------------------- p and q using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

well_formed q
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p

well_formed q
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

Γ Ⱶ "H4" ∶ p and q ---> q, "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

Γ Ⱶ "H4" ∶ p and q ---> q, "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, -------------------------------------- p and q using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- r using BasicReasoning
(* This pattern is basically an "apply ... in" *)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

well_formed (q ---> r)
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, "H4" ∶ q ---> r, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q

well_formed (q ---> r)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)
Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, "H4" ∶ q ---> r, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- q ---> r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, -------------------------------------- p using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, "H4" ∶ q ---> r, -------------------------------------- r using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
Hwf: well_formed p
Hwf0: well_formed q
Hwf1: well_formed (q ---> r)

Γ Ⱶ "H0" ∶ p ---> q ---> r, "H1" ∶ p and q, "H2" ∶ p, "H3" ∶ q, "H4" ∶ q ---> r, -------------------------------------- q using BasicReasoning
mlExact "H3". Defined.
Σ: Signature
Γ: Theory
l: list Pattern
p, q, r: Pattern

Pattern.wf l → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
p, q, r: Pattern

Pattern.wf l → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf l
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i foldr patt_imp r ([] ++ [p]) ---> foldr patt_imp r ([] ++ [q]) ---> foldr patt_imp r ([] ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf (a :: l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i foldr patt_imp r ([] ++ [p]) ---> foldr patt_imp r ([] ++ [q]) ---> foldr patt_imp r ([] ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i (p ---> r) ---> (q ---> r) ---> p or q ---> r using BasicReasoning
apply prf_disj_elim; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf (a :: l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: Pattern.wf (a :: l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: foldr andb true (map well_formed (a :: l))
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: well_formed a && foldr andb true (map well_formed l)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfl: well_formed a = true ∧ foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i foldr patt_imp r ((a :: l) ++ [p]) ---> foldr patt_imp r ((a :: l) ++ [q]) ---> foldr patt_imp r ((a :: l) ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp r (l ++ [p])) ---> (a ---> foldr patt_imp r (l ++ [q])) ---> a ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

well_formed ((a ---> foldr patt_imp r (l ++ [p])) ---> (a ---> foldr patt_imp r (l ++ [q])) ---> a ---> foldr patt_imp r (l ++ [p or q]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Γ Ⱶ (a ---> foldr patt_imp r (l ++ [p])) ---> (a ---> foldr patt_imp r (l ++ [q])) ---> a ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

well_formed ((a ---> foldr patt_imp r (l ++ [p])) ---> (a ---> foldr patt_imp r (l ++ [q])) ---> a ---> foldr patt_imp r (l ++ [p or q]))
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ Ⱶ (a ---> foldr patt_imp r (l ++ [p])) ---> (a ---> foldr patt_imp r (l ++ [q])) ---> a ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), -------------------------------------- (a ---> foldr patt_imp r (l ++ [q])) ---> a ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), -------------------------------------- a ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

well_formed (foldr patt_imp r (l ++ [p]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, -------------------------------------- foldr patt_imp r (l ++ [p]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)

well_formed (foldr patt_imp r (l ++ [p]))
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, -------------------------------------- foldr patt_imp r (l ++ [p]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, -------------------------------------- foldr patt_imp r (l ++ [p]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, -------------------------------------- a using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))

well_formed (foldr patt_imp r (l ++ [q]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- foldr patt_imp r (l ++ [q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))

well_formed (foldr patt_imp r (l ++ [q]))
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- foldr patt_imp r (l ++ [q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- foldr patt_imp r (l ++ [q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), -------------------------------------- a using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))

well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), "H6" ∶ foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))

well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))
Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), "H6" ∶ foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), -------------------------------------- foldr patt_imp r (l ++ [p]) using BasicReasoning
mlExact "H4".
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), "H6" ∶ foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), -------------------------------------- foldr patt_imp r (l ++ [p or q]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl: foldr andb true (map well_formed l) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl: Γ ⊢i foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]) using BasicReasoning
wfal: Pattern.wf (a :: l)
Hwf: well_formed (foldr patt_imp r (l ++ [p]))
Hwf0: well_formed (foldr patt_imp r (l ++ [q]))
Hwf1: well_formed (foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]))

Γ Ⱶ "H3" ∶ foldr patt_imp r (l ++ [p]) ---> foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), "H0" ∶ a ---> foldr patt_imp r (l ++ [p]), "H1" ∶ a ---> foldr patt_imp r (l ++ [q]), "H2" ∶ a, "H4" ∶ foldr patt_imp r (l ++ [p]), "H5" ∶ foldr patt_imp r (l ++ [q]), "H6" ∶ foldr patt_imp r (l ++ [q]) ---> foldr patt_imp r (l ++ [p or q]), -------------------------------------- foldr patt_imp r (l ++ [q]) using BasicReasoning
mlExact "H5". Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern

Pattern.wf l₁ → Pattern.wf l₂ → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern

Pattern.wf l₁ → Pattern.wf l₂ → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
wfl₁: Pattern.wf l₁
wfl₂: Pattern.wf l₂
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
Σ: Signature
Γ: Theory
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf l₂
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r

l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl₂: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
l₁: list Pattern
wfl₁: Pattern.wf l₁

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ []) ---> foldr patt_imp r (l₁ ++ [q] ++ []) ---> foldr patt_imp r (l₁ ++ [p or q] ++ []) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf (a :: l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl₂: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
l₁: list Pattern
wfl₁: Pattern.wf l₁

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ []) ---> foldr patt_imp r (l₁ ++ [q] ++ []) ---> foldr patt_imp r (l₁ ++ [p or q] ++ []) using BasicReasoning
Σ: Signature
Γ: Theory
p, q, r: Pattern
wfl₂: Pattern.wf []
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
l₁: list Pattern
wfl₁: Pattern.wf l₁

Γ ⊢i foldr patt_imp r (l₁ ++ [p]) ---> foldr patt_imp r (l₁ ++ [q]) ---> foldr patt_imp r (l₁ ++ [p or q]) using BasicReasoning
apply prf_disj_elim_iter; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf (a :: l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: Pattern.wf (a :: l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: foldr andb true (map well_formed (a :: l₂))
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: well_formed a && foldr andb true (map well_formed l₂)
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfl₂: well_formed a = true ∧ foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ a :: l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂) using BasicReasoning
(* Or we can swap p and a (move a to the end of l_1) *)
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(A ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(A ---> B ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(A ---> B ---> C) =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i A ---> B ---> C using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(A ---> B ---> C) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(A ---> B ---> C) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (A ---> B ---> C) [] =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (B ---> C) ([] ++ [A]) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp C (([] ++ [A]) ++ [B]) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp C [A; B] =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp C [foldr patt_imp r (l₁ ++ p :: a :: l₂); B] =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp C [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Pattern.wf [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed ?g
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i ?g ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp ?g [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i ?g ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(?g ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(?g ---> foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(?g ---> foldr patt_imp r (l₁ ++ [p or q; a] ++ l₂)) =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i ?g ---> foldr patt_imp r (l₁ ++ [p or q; a] ++ l₂) using BasicReasoning
apply prf_reorder_iter; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Pattern.wf [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ [a; p or q] ++ l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ [a; p or q] ++ l₂)) [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ [a; p or q] ++ l₂)) [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) [] =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) (([] ++ [foldr patt_imp r (l₁ ++ p :: a :: l₂)]) ++ [foldr patt_imp r (l₁ ++ q :: a :: l₂)]) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ q :: a :: l₂)] =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ q :: a :: l₂)]) =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ q :: a :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Pattern.wf [foldr patt_imp r (l₁ ++ p :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: q :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ q :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: q :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ q :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: q :: l₂) using BasicReasoning
apply prf_reorder_iter; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Pattern.wf [foldr patt_imp r (l₁ ++ p :: a :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: q :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ q :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([foldr patt_imp r (l₁ ++ p :: a :: l₂)] ++ [foldr patt_imp r (l₁ ++ a :: q :: l₂)]) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([] ++ [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ a :: q :: l₂)]) =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([] ++ [foldr patt_imp r (l₁ ++ p :: a :: l₂); foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf [foldr patt_imp r (l₁ ++ a :: q :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: p :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ p :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: p :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([] ++ [foldr patt_imp r (l₁ ++ a :: p :: l₂); foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ p :: a :: l₂) ---> foldr patt_imp r (l₁ ++ a :: p :: l₂) using BasicReasoning
apply prf_reorder_iter; wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Pattern.wf []
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Pattern.wf [foldr patt_imp r (l₁ ++ a :: q :: l₂)]
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: p :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ p :: a :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
well_formed (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂))
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([] ++ [foldr patt_imp r (l₁ ++ a :: p :: l₂); foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp (foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) ([] ++ [foldr patt_imp r (l₁ ++ a :: p :: l₂); foldr patt_imp r (l₁ ++ a :: q :: l₂)]) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp r (l₁ ++ a :: p :: l₂) ---> foldr patt_imp r (l₁ ++ a :: q :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂) using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r (l₁ ++ a :: p :: l₂) ---> foldr patt_imp r (l₁ ++ a :: q :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)
Γ ⊢i using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r (l₁ ++ a :: p :: l₂) ---> foldr patt_imp r (l₁ ++ a :: q :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ a :: q :: l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) ---> foldr patt_imp r ((l₁ ++ [a]) ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ a :: (p or q) :: l₂)) =
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

(foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) ---> foldr patt_imp r ((l₁ ++ [a]) ++ [q] ++ l₂) ---> foldr patt_imp r ((l₁ ++ [a]) ++ [p or q] ++ l₂)) =
reflexivity.
Σ: Signature
Γ: Theory
a: Pattern
l₂: list Pattern
p, q, r: Pattern
wfa: well_formed a = true
wfl₂: foldr andb true (map well_formed l₂) = true
wfp: well_formed p
wfq: well_formed q
wfr: well_formed r
IHl₂: Pattern.wf l₂ → l₁ : list Pattern, Pattern.wf l₁ → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
l₁: list Pattern
wfl₁: Pattern.wf l₁
wfal₂: Pattern.wf (a :: l₂)
A: Pattern
HeqA: A = foldr patt_imp r (l₁ ++ p :: a :: l₂)
B: Pattern
HeqB: B = foldr patt_imp r (l₁ ++ q :: a :: l₂)
C: Pattern
HeqC: C = foldr patt_imp r (l₁ ++ (p or q) :: a :: l₂)

Γ ⊢i foldr patt_imp r ((l₁ ++ [a]) ++ [p] ++ l₂) ---> foldr patt_imp r ((l₁ ++ [a]) ++ [q] ++ l₂) ---> foldr patt_imp r ((l₁ ++ [a]) ++ [p or q] ++ l₂) using BasicReasoning
apply IHl₂; wf_auto2. Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo

Pattern.wf l₁ → Pattern.wf l₂ → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i → Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo

Pattern.wf l₁ → Pattern.wf l₂ → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i → Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i

Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) ---> foldr patt_imp r (l₁ ++ [q] ++ l₂) ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using BasicReasoning
apply prf_disj_elim_iter_2; wf_auto2. Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo

Pattern.wf l₁ → Pattern.wf l₂ → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i → Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i → Γ ⊢i foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo

Pattern.wf l₁ → Pattern.wf l₂ → well_formed p → well_formed q → well_formed r → Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i → Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i → Γ ⊢i foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i

Γ ⊢i foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp r (l₁ ++ [p or q] ++ l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i

Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
apply H.
Σ: Signature
Γ: Theory
l₁, l₂: list Pattern
p, q, r: Pattern
i: ProofInfo
WFl1: Pattern.wf l₁
WFl2: Pattern.wf l₂
WFp: well_formed p
WFq: well_formed q
WFr: well_formed r
H: Γ ⊢i foldr patt_imp r (l₁ ++ [p] ++ l₂) using i
H0: Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i

Γ ⊢i foldr patt_imp r (l₁ ++ [q] ++ l₂) using i
apply H0. Defined.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo

Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i → Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i → Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo

Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i → Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i → Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i
H2: Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i

Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i ))) → mlTheory (Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i ))) using mlInfo (Γ Ⱶ l₁ ++ (pn ∶ p, ) ++ l₂-------------------------------------- r using i )
H2: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i ))) → mlTheory (Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i ))) using mlInfo (Γ Ⱶ l₁ ++ (qn ∶ q, ) ++ l₂-------------------------------------- r using i )

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i ))) → mlTheory (Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i ))) using mlInfo (Γ Ⱶ l₁ ++ (pqn ∶ p or q, ) ++ l₂-------------------------------------- r using i )
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r → Pattern.wf (patterns_of (l₁ ++ (pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (patterns_of (l₁ ++ (pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (patterns_of (l₁ ++ (qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (patterns_of (l₁ ++ (qn ∶ q) :: l₂)) using i

well_formed r → Pattern.wf (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂)) → Γ ⊢i foldr patt_imp r (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r → Pattern.wf (patterns_of (l₁ ++ (pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (patterns_of (l₁ ++ (pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (patterns_of (l₁ ++ (qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (patterns_of (l₁ ++ (qn ∶ q) :: l₂)) using i
wfr: well_formed r
Hwf: Pattern.wf (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂))

Γ ⊢i foldr patt_imp r (patterns_of (l₁ ++ (pqn ∶ p or q) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r → Pattern.wf (map nh_patt (l₁ ++ (pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt (l₁ ++ (pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt (l₁ ++ (qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt (l₁ ++ (qn ∶ q) :: l₂)) using i
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))

Γ ⊢i foldr patt_imp r (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H1: well_formed r → Pattern.wf (map nh_patt (l₁ ++ (pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt (l₁ ++ (pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt (l₁ ++ (qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt (l₁ ++ (qn ∶ q) :: l₂)) using i
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))

Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
H2: well_formed r → Pattern.wf (map nh_patt (l₁ ++ (qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt (l₁ ++ (qn ∶ q) :: l₂)) using i
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i

Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i

Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂)) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ [p] ++ (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ [q] ++ (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ [p] ++ (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
well_formed r
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
Hwf: Pattern.wf (map nh_patt (l₁ ++ (pqn ∶ p or q) :: l₂))
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf (map nh_patt l₁)
abstract (apply wfl₁hl₂_proj_l₁ in Hwf; exact Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
abstract (apply wfl₁hl₂_proj_l₂ in Hwf; exact Hwf).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

well_formed p
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

well_formed p
abstract (apply wfl₁hl₂_proj_h in Hwf; wf_auto2).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

well_formed q
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

well_formed q
abstract (apply wfl₁hl₂_proj_h in Hwf; wf_auto2).
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (map nh_patt ((pn ∶ p) :: l₂)) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (map nh_patt ((pn ∶ p) :: l₂)) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (p :: map nh_patt l₂) = true
wf_auto2.
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂))
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ p or q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ p or q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (map nh_patt ((qn ∶ q) :: l₂)) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (map nh_patt ((qn ∶ q) :: l₂)) = true
Σ: Signature
Γ: Theory
l₁, l₂: list named_hypothesis
pn: string
p: Pattern
qn: string
q: Pattern
pqn: string
r: Pattern
i: ProofInfo
wfr: well_formed r
H1: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((pn ∶ p) :: l₂)) using i
H2: well_formed r → Pattern.wf (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) → Γ ⊢i foldr patt_imp r (map nh_patt l₁ ++ map nh_patt ((qn ∶ q) :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((pqn ∶ (p ---> ⊥) ---> q) :: l₂))
H: Pattern.wf (map nh_patt l₁)
H0: well_formed (nh_patt (pqn ∶ (p ---> ⊥) ---> q))
H3: Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)

Pattern.wf (q :: map nh_patt l₂) = true
wf_auto2. } Defined. Tactic Notation "mlDestructOr" constr(name) "as" constr(name1) constr(name2) := _ensureProofMode; _failIfUsed name1; _failIfUsed name2; match goal with | |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) => let Htd := fresh "Htd" in eapply cast_proof_ml_hyps; f_equal; _mlReshapeHypsByName name; apply MLGoal_disj_elim with (pqn := name) (pn := name1) (qn := name2); _mlReshapeHypsBack; simpl end. Tactic Notation "mlDestructOr" constr(name) := _ensureProofMode; let hyps := _getHypNames in let name0 := eval cbv in (fresh hyps) in let name1 := eval cbv in (fresh (name0 :: hyps)) in mlDestructOr name as name0 name1.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed p → well_formed q → well_formed c → Γ ⊢i a ---> p ---> b ---> c using i → Γ ⊢i a ---> q ---> b ---> c using i → Γ ⊢i a ---> p or q ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed p → well_formed q → well_formed c → Γ ⊢i a ---> p ---> b ---> c using i → Γ ⊢i a ---> q ---> b ---> c using i → Γ ⊢i a ---> p or q ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ ⊢i a ---> p or q ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

well_formed (a ---> p or q ---> b ---> c)
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ a ---> p or q ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

well_formed (a ---> p or q ---> b ---> c)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ a ---> p or q ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ "H0" ∶ a, -------------------------------------- p or q ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ "H0" ∶ a, "H1" ∶ p or q, -------------------------------------- b ---> c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ "H0" ∶ a, "H1" ∶ p or q, "H2" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ "H0" ∶ a, "0" ∶ p, "H2" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i
Γ Ⱶ "H0" ∶ a, "1" ∶ q, "H2" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ "H0" ∶ a, "0" ∶ p, "H2" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ ⊢i a ---> p ---> b ---> c using i
apply H.
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ Ⱶ "H0" ∶ a, "1" ∶ q, "H2" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, p, q, c: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
WFp: well_formed p
WFq: well_formed q
WFc: well_formed c
H: Γ ⊢i a ---> p ---> b ---> c using i
H0: Γ ⊢i a ---> q ---> b ---> c using i

Γ ⊢i a ---> q ---> b ---> c using i
apply H0. Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i B ---> A using i → Γ ⊢i A <---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A ---> B using i → Γ ⊢i B ---> A using i → Γ ⊢i A <---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
AimplB: Γ ⊢i A ---> B using i
BimplA: Γ ⊢i B ---> A using i

Γ ⊢i A <---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
AimplB: Γ ⊢i A ---> B using i
BimplA: Γ ⊢i B ---> A using i

Γ ⊢i (A ---> B) and (B ---> A) using i
apply conj_intro_meta; try_wfauto2; assumption. Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A <---> B using i → Γ ⊢i A ---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A <---> B using i → Γ ⊢i A ---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i

Γ ⊢i A ---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i (A ---> B) and (B ---> A) using i

Γ ⊢i A ---> B using i
apply pf_conj_elim_l_meta in H; try_wfauto2; assumption. Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A <---> B using i → Γ ⊢i B ---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A <---> B using i → Γ ⊢i B ---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i

Γ ⊢i B ---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i (A ---> B) and (B ---> A) using i

Γ ⊢i B ---> A using i
apply pf_conj_elim_r_meta in H; try_wfauto2; assumption. Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → (Γ ⊢i A <---> B using i → (Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)) * ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i) → Γ ⊢i A <---> B using i)
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → (Γ ⊢i A <---> B using i → (Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)) * ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i) → Γ ⊢i A <---> B using i)
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B

((Γ ⊢i A <---> B using i → (Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i)) * ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i) → Γ ⊢i A <---> B using i))%type
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i

((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Γ ⊢i A <---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i

((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
H1: Γ ⊢i A ---> B using i

((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A <---> B using i
H1: Γ ⊢i A ---> B using i
H2: Γ ⊢i B ---> A using i

((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
split; assumption.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type

Γ ⊢i A <---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type

Γ ⊢i A <---> B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H1: Γ ⊢i A ---> B using i
H2: Γ ⊢i B ---> A using i

Γ ⊢i A <---> B using i
apply pf_iff_split; assumption. } Defined.
Σ: Signature
Γ: Theory
A: Pattern

well_formed A → Γ ⊢i A <---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern

well_formed A → Γ ⊢i A <---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
WFA: well_formed A

Γ ⊢i A <---> A using BasicReasoning
apply pf_iff_split; try_wfauto2; apply A_impl_A; assumption. Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A <---> B using i → Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H: Γ ⊢i A <---> B using i

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H, H2: Γ ⊢i A <---> B using i

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H: Γ ⊢i A <---> B using i
H2: Γ ⊢i B ---> A using i

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H1: Γ ⊢i A <---> B using i
H2: Γ ⊢i B ---> A using i

Γ ⊢i B <---> A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
H1: Γ ⊢i A ---> B using i
H2: Γ ⊢i B ---> A using i

Γ ⊢i B <---> A using i
apply pf_iff_split; try_wfauto2; assumption. Defined.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A <---> B using i → Γ ⊢i B <---> C using i → Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A <---> B using i → Γ ⊢i B <---> C using i → Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AeqB: Γ ⊢i A <---> B using i
BeqC: Γ ⊢i B <---> C using i

Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AeqB: ((Γ ⊢i A ---> B using i) * (Γ ⊢i B ---> A using i))%type
BeqC: Γ ⊢i B <---> C using i

Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BeqC: Γ ⊢i B <---> C using i

Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BeqC: ((Γ ⊢i B ---> C using i) * (Γ ⊢i C ---> B using i))%type

Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

Γ ⊢i A <---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

((Γ ⊢i A ---> C using i) * (Γ ⊢i C ---> A using i))%type
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

Γ ⊢i A ---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i C ---> A using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

Γ ⊢i A ---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

well_formed A
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed ?B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed C
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i A ---> ?B using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i ?B ---> C using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

well_formed A
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed C
1-3: wf_auto2.
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

Γ ⊢i C ---> A using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

Γ ⊢i C ---> A using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

well_formed C
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed ?B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed A
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i C ---> ?B using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
Γ ⊢i ?B ---> A using i
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i

well_formed C
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed B
Σ: Signature
Γ: Theory
A, B, C: Pattern
i: ProofInfo
wfA: well_formed A
wfB: well_formed B
wfC: well_formed C
AimpB: Γ ⊢i A ---> B using i
BimpA: Γ ⊢i B ---> A using i
BimpC: Γ ⊢i B ---> C using i
CimpB: Γ ⊢i C ---> B using i
well_formed A
1-3: wf_auto2. } Defined.
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo

well_formed a → well_formed b → Γ ⊢i b using i → Γ ⊢i a ---> b using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo

well_formed a → well_formed b → Γ ⊢i b using i → Γ ⊢i a ---> b using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i

Γ ⊢i a ---> b using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i
Γ ⊢i ?ϕ₁ ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i

Γ ⊢i b ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b: Pattern
i: ProofInfo
WFa: well_formed a
WFb: well_formed b
H: Γ ⊢i b using i

Γ ⊢i b ---> a ---> b using BasicReasoning
apply P1; wf_auto2. Defined.
Σ: Signature
Γ: Theory
p1, p2: Pattern

well_formed p1 → well_formed p2 → Γ ⊢i ! (! p1 ---> p2) <---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern

well_formed p1 → well_formed p2 → Γ ⊢i ! (! p1 ---> p2) <---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! (! p1 ---> p2) <---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2)
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! (! p1 ---> p2) ---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ ! (! p1 ---> p2) ---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (! p1 ---> p2) ---> ! p1 and ! p2)
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ ! (! p1 ---> p2) ---> ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! (! p1 ---> p2), -------------------------------------- ! p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! (! p1 ---> p2), "H1" ∶ ! ! p1 or ! ! p2, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 or ! ! p2, -------------------------------------- ! p1 ---> p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 or ! ! p2, "H2" ∶ ! p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! ! p1 ---> ! ! p2, "H2" ∶ ! p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! ! p1 ---> ! ! p2, "H2" ∶ ! p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! ! p1 ---> ! ! p2, "H2" ∶ ! p1, -------------------------------------- ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! ! p1 ---> ! ! p2, "H2" ∶ ! p1, -------------------------------------- ! ! ! p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ ! p1 ---> ! ! ! p1, "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! ! p1 ---> ! ! p2, "H2" ∶ ! p1, -------------------------------------- ! ! ! p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ ! p1 ---> ! ! ! p1, "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (! p1 ---> p2) ---> ⊥, "H1" ∶ ! ! ! p1 ---> ! ! p2, "H2" ∶ ! p1, -------------------------------------- ! p1 using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! p1 and ! p2 ---> ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ ! p1 and ! p2 ---> ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! p1 and ! p2 ---> ! (! p1 ---> p2))
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ ! p1 and ! p2 ---> ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! p1 and ! p2, -------------------------------------- ! (! p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! p1 and ! p2, "H1" ∶ ! p1 ---> p2, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! (! ! p1 or ! ! p2), "H1" ∶ ! p1 ---> p2, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! ! p1 or ! ! p2 ---> ⊥, "H1" ∶ ! p1 ---> p2, -------------------------------------- ! ! p1 or ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, -------------------------------------- ! ! ! p1 ---> ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, "H2" ∶ ! ! ! p1, -------------------------------------- ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, "H2" ∶ ! ! ! p1, -------------------------------------- ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, "H2" ∶ ! ! ! p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, "H2" ∶ ! ! ! p1, -------------------------------------- ! p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ ! ! ! p1 ---> ! p1, "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, "H2" ∶ ! ! ! p1, -------------------------------------- ! p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ ! ! ! p1 ---> ! p1, "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ ! p1 ---> p2, "H2" ∶ ! ! ! p1, -------------------------------------- ! ! ! p1 using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
p1, p2: Pattern

well_formed p1 → well_formed p2 → Γ ⊢i ! (p1 ---> p2) <---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern

well_formed p1 → well_formed p2 → Γ ⊢i ! (p1 ---> p2) <---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! (p1 ---> p2) <---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (p1 ---> p2) ---> p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (p1 ---> p2) ---> p1 and ! p2)
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i ! (p1 ---> p2) ---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (p1 ---> p2) ---> p1 and ! p2)
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ ! (p1 ---> p2) ---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (! (p1 ---> p2) ---> p1 and ! p2)
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ ! (p1 ---> p2) ---> p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! (p1 ---> p2), -------------------------------------- p1 and ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! (p1 ---> p2), "H1" ∶ ! p1 or ! ! p2, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! p1 or ! ! p2, -------------------------------------- p1 ---> p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! p1 or ! ! p2, "H2" ∶ p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 ---> ! ! p2, "H2" ∶ p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 ---> ! ! p2, "H2" ∶ p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 ---> ! ! p2, "H2" ∶ p1, -------------------------------------- ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 ---> ! ! p2, "H2" ∶ p1, -------------------------------------- ! ! p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ p1 ---> ! ! p1, "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 ---> ! ! p2, "H2" ∶ p1, -------------------------------------- ! ! p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ p1 ---> ! ! p1, "H3" ∶ ! ! p2 ---> p2, "H0" ∶ (p1 ---> p2) ---> ⊥, "H1" ∶ ! ! p1 ---> ! ! p2, "H2" ∶ p1, -------------------------------------- p1 using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ ⊢i p1 and ! p2 ---> ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2
Γ Ⱶ p1 and ! p2 ---> ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

well_formed (p1 and ! p2 ---> ! (p1 ---> p2))
wf_auto2.
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ p1 and ! p2 ---> ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ p1 and ! p2, -------------------------------------- ! (p1 ---> p2) using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ p1 and ! p2, "H1" ∶ p1 ---> p2, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ ! p1 or ! ! p2 ---> ⊥, "H1" ∶ p1 ---> p2, -------------------------------------- ! p1 or ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, -------------------------------------- ! ! p1 ---> ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, "H2" ∶ ! ! p1, -------------------------------------- ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, "H2" ∶ ! ! p1, -------------------------------------- ! ! p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, "H2" ∶ ! ! p1, -------------------------------------- p2 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, "H2" ∶ ! ! p1, -------------------------------------- p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ ! ! p1 ---> p1, "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, "H2" ∶ ! ! p1, -------------------------------------- p1 using BasicReasoning
Σ: Signature
Γ: Theory
p1, p2: Pattern
wfp1: well_formed p1
wfp2: well_formed p2

Γ Ⱶ "H4" ∶ ! ! p1 ---> p1, "H3" ∶ p2 ---> ! ! p2, "H0" ∶ (! ! p1 ---> ! ! p2) ---> ⊥, "H1" ∶ p1 ---> p2, "H2" ∶ ! ! p1, -------------------------------------- ! ! p1 using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A using i → Γ ⊢i B ---> A and B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A using i → Γ ⊢i B ---> A and B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i B ---> A and B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ ---> B ---> A and B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i ?ϕ₁ using i
exact H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i A ---> B ---> A and B using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i A ---> B ---> A and B using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed A
wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed B
wf_auto2. } Defined.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A using i → Γ ⊢i A and B ---> C using i → Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A using i → Γ ⊢i A and B ---> C using i → Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed (A and B)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed B
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed (A and B)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed (A and B)
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed C
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A and B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

Γ ⊢i A and B ---> C using i
exact H0.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

Γ ⊢i B ---> A and B using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed A
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i
Γ ⊢i A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

well_formed B
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i A and B ---> C using i

Γ ⊢i A using i
exact H. Defined.
Σ: Signature
Γ: Theory
A, B: Pattern

well_formed A → well_formed B → Γ ⊢i A ---> B ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern

well_formed A → well_formed B → Γ ⊢i A ---> B ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

Γ ⊢i A ---> B ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed (B and A)
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed B
wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed (B and A)
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed A
wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed (B and A)
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
Γ ⊢i B ---> A ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed (B and A)
wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

Γ ⊢i B ---> A ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B
well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed B
wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
WFA: well_formed A
WFB: well_formed B

well_formed A
wf_auto2. } Defined.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A using i → Γ ⊢i B ---> B and A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A using i → Γ ⊢i B ---> B and A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i B ---> B and A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
Γ ⊢i ?ϕ₁ ---> B ---> B and A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i ?ϕ₁ using i
exact H.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i A ---> B ---> B and A using i
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

Γ ⊢i A ---> B ---> B and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed A
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i
well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed A
wf_auto2.
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed B
Σ: Signature
Γ: Theory
A, B: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A using i

well_formed B
wf_auto2. } Defined.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A using i → Γ ⊢i B and A ---> C using i → Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A using i → Γ ⊢i B and A ---> C using i → Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed (B and A)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed B
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed (B and A)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed (B and A)
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed C
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i B and A ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

Γ ⊢i B ---> B and A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed A
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i
Γ ⊢i A using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

well_formed B
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A using i
H0: Γ ⊢i B and A ---> C using i

Γ ⊢i A using i
exact H. Defined.
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A and B using i → Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → Γ ⊢i A and B using i → Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i

Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i

Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed A
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed B
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
P2: Γ ⊢i A using i

Γ ⊢i B and A using i
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
well_formed A
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
well_formed B
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed A
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
well_formed B
Σ: Signature
A, B: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
H: Γ ⊢i A and B using i
P1: Γ ⊢i B using i
P2: Γ ⊢i A using i

Γ ⊢i B and A using i
apply conj_intro_meta; assumption. Defined.
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo

Γ ⊢i r' ---> r using i → l : hypotheses, Γ Ⱶ l-------------------------------------- r' using i → Γ Ⱶ l-------------------------------------- r using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo

Γ ⊢i r' ---> r using i → l : hypotheses, Γ Ⱶ l-------------------------------------- r' using i → Γ Ⱶ l-------------------------------------- r using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: Γ Ⱶ l-------------------------------------- r' using i

Γ Ⱶ l-------------------------------------- r using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- r' using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- r' using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- r' using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- r' using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- r' using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- r' using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- r using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- r using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- r using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- r using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- r using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- r using i )
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i

well_formed r → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r (patterns_of l) using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp r (patterns_of l) using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed ?g
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> r using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp r' (patterns_of l) using i
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)

well_formed r'
Σ: Signature
Γ: Theory
r, r': Pattern
i: ProofInfo
Himp: Γ ⊢i r' ---> r using i
l: hypotheses
H: well_formed r' → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp r' (patterns_of l) using i
wfr: well_formed r
wfl: Pattern.wf (patterns_of l)
well_formed r'
1,2: pose proof (wfrr' := proved_impl_wf _ _ (proj1_sig Himp)); wf_auto2. Defined. Ltac _mlApplyMetaRaw t := eapply (@MLGoal_applyMeta _ _ _ _ _ t). Tactic Notation "mlApplyMetaRaw" uconstr(t) := _mlApplyMetaRaw t. Ltac2 _mlApplyMetaRaw (t : constr) := eapply (@MLGoal_applyMeta _ _ _ _ _ $t).
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo

Γ Ⱶ l-------------------------------------- x using i → Γ Ⱶ l-------------------------------------- x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo

Γ Ⱶ l-------------------------------------- x using i → Γ Ⱶ l-------------------------------------- x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: Γ Ⱶ l-------------------------------------- x using i

Γ Ⱶ l-------------------------------------- x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- x using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- x using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- x using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- x using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- x using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- x using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- x or y using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- x or y using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- x or y using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- x or y using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- x or y using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- x or y using i )
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i

well_formed (x or y) → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp (x or y) (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp (x or y) (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed ?g
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i ?g ---> x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i ?g ---> x or y using BasicReasoning
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed y
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed x
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp x (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed (x or y)
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp x (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed x
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed x → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp x (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
assumption. } Defined.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo

Γ Ⱶ l-------------------------------------- y using i → Γ Ⱶ l-------------------------------------- x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo

Γ Ⱶ l-------------------------------------- y using i → Γ Ⱶ l-------------------------------------- x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: Γ Ⱶ l-------------------------------------- y using i

Γ Ⱶ l-------------------------------------- x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- y using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- y using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- y using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- y using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- y using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- y using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- x or y using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- x or y using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- x or y using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- x or y using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- x or y using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- x or y using i )
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i

well_formed (x or y) → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp (x or y) (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp (x or y) (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed ?g
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i ?g ---> x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp ?g (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i ?g ---> x or y using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i ?g ---> x or y using BasicReasoning
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed x
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed y
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed y
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed (x or y)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp y (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed (x or y)
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp y (patterns_of l) using i
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed y
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

well_formed y
wf_auto2.
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
l: hypotheses
x, y: Pattern
i: ProofInfo
H: well_formed y → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp y (patterns_of l) using i
wfxy: well_formed (x or y)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
assumption. } Defined. Ltac mlLeft := _ensureProofMode; apply MLGoal_left. Ltac mlRight := _ensureProofMode; apply MLGoal_right.
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i a ---> a or a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i a ---> a or a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ ⊢i a ---> a or a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (a ---> a or a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ a ---> a or a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (a ---> a or a)
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ a ---> a or a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H0" ∶ a, -------------------------------------- a or a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H0" ∶ a, -------------------------------------- a using BasicReasoning
mlExact "H0". Defined.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo

Γ ⊢i r ---> r' using i → (l₁ l₂ : list named_hypothesis) (g : Pattern), Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i → Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo

Γ ⊢i r ---> r' using i → (l₁ l₂ : list named_hypothesis) (g : Pattern), Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i → Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i

Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (n' ∶ r') :: l₂-------------------------------------- g using i )

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (n ∶ r) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (n' ∶ r') :: l₂)) using i

well_formed g → Pattern.wf (patterns_of (l₁ ++ (n ∶ r) :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (n ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: well_formed g → Pattern.wf (patterns_of (l₁ ++ (n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (n' ∶ r') :: l₂)) using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (n ∶ r) :: l₂))

Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (n ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: Pattern.wf (patterns_of (l₁ ++ (n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (n' ∶ r') :: l₂)) using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (n ∶ r) :: l₂))

Γ ⊢i foldr patt_imp g (patterns_of (l₁ ++ (n ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
H: Pattern.wf (map nh_patt (l₁ ++ (n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt (l₁ ++ (n' ∶ r') :: l₂)) using i
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))

Γ ⊢i foldr patt_imp g (map nh_patt (l₁ ++ (n ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i

Γ ⊢i foldr patt_imp g (map nh_patt (l₁ ++ (n ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i

Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂)) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed ?h
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Γ ⊢i nh_patt (n ∶ r) ---> ?h using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ ?h :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ r' :: (fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂) using i
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
Hwf: Pattern.wf (map nh_patt (l₁ ++ (n ∶ r) :: l₂))
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

Pattern.wf (map nh_patt l₁)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

Pattern.wf (map nh_patt l₁)
abstract (apply wfapp_proj_1 in Hwf; exact Hwf).
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

Pattern.wf ((fix map (l : list named_hypothesis) : list Pattern := match l with | [] => [] | a :: t => nh_patt a :: map t end) l₂)
abstract (apply wfl₁hl₂_proj_l₂ in Hwf; exact Hwf).
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

well_formed r'
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

well_formed r'
abstract (pose proof (Himp' := proj1_sig Himp); apply proved_impl_wf in Himp'; wf_auto2).
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

well_formed (nh_patt (n ∶ r))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

well_formed (nh_patt (n ∶ r))
abstract (apply wfl₁hl₂_proj_h in Hwf; exact Hwf).
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

well_formed g
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))
Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

well_formed g
exact wfg.
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
Σ: Signature
Γ: Theory
n: string
r: Pattern
n': string
r': Pattern
i: ProofInfo
Himp: Γ ⊢i r ---> r' using i
l₁, l₂: list named_hypothesis
g: Pattern
wfg: well_formed g
H: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) → Γ ⊢i foldr patt_imp g (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂)) using i
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n ∶ r) :: l₂))

Pattern.wf (map nh_patt l₁ ++ map nh_patt ((n' ∶ r') :: l₂))
abstract( pose proof (wfapp_proj_1 _ _ Hwf); pose proof (wfl₁hl₂_proj_l₂ _ _ _ Hwf); pose proof (wfl₁hl₂_proj_h _ _ _ Hwf); unfold Pattern.wf; rewrite map_app; rewrite foldr_app; simpl; pose proof (Himp' := proj1_sig Himp); apply proved_impl_wf in Himp'; apply well_formed_imp_proj2 in Himp'; rewrite Himp'; simpl; unfold Pattern.wf in H1; rewrite H1; exact H0 ). } Defined. Ltac _mlApplyMetaRawIn t name := eapply cast_proof_ml_hyps; f_equal; _mlReshapeHypsByName name; eapply (@MLGoal_applyMetaIn _ _ _ _ name _ _ t); _mlReshapeHypsBack. Ltac2 _mlApplyMetaRawIn (t : constr) (name : constr) := ltac1:(t' name' |- _mlApplyMetaRawIn t' name') (Ltac1.of_constr t) (Ltac1.of_constr name) . Tactic Notation "mlApplyMetaRaw" uconstr(t) "in" constr(name) := _mlApplyMetaRawIn t name.
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i p ---> p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i p ---> p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p ---> p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed (p ---> p or q)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ p ---> p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed (p ---> p or q)
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ p ---> p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ p, -------------------------------------- p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ p or q, -------------------------------------- p or q using BasicReasoning
mlExact "H0". Defined. Ltac2 rec applyRec (f : constr) (xs : constr list) : constr option := match xs with | [] => Some f | y::ys => lazy_match! Constr.type f with | (forall _ : ?t, _) => Control.plus (fun () => applyRec constr:($f $y) ys) (fun _ => None) | _ => None end end.
- : constr option = Some (constr:(1 + 2))
(* All thic complicated code is here only for one reason: I want to be able to first run the tactic with all the parameters inferred or question marked, which results in another goal. And then I want to handle the subgoals generated by the filling-in underscores / question marks. In particular, I want the proof mode goals to be generated first, and the other, uninteresting goals, next. *) Ltac2 rec fillWithUnderscoresAndCall (tac : constr -> unit) (t : constr) (args : constr list) := (* Message.print ( Message.concat (Message.of_string "fillWithUnderscoresAndCall: t = ") (Message.of_constr t) ); Message.print ( Message.concat (Message.of_string "fillWithUnderscoresAndCall: args = ") (List.fold_right (Message.concat) (Message.of_string "") (List.map Message.of_constr args)) ); *) let cont := (fun () => lazy_match! Constr.type t with | (?t' -> ?t's) => lazy_match! goal with | [|- ?g] => let h := Fresh.in_goal ident:(h) in assert(h : $t' -> $g) > [( let pftprime := Fresh.in_goal ident:(pftprime) in intro $pftprime; let new_t := open_constr:($t ltac2:(Notations.exact0 false (fun () => Control.hyp (pftprime)))) in fillWithUnderscoresAndCall tac new_t args; Std.clear [pftprime] )|(apply &h) ] end | (forall _ : _, _) => fillWithUnderscoresAndCall tac open_constr:($t _) args | ?remainder => throw (Invalid_argument (Some (Message.concat (Message.concat (Message.of_string "Remainder type: ") (Message.of_constr remainder)) (Message.concat (Message.of_string ", of term") (Message.of_constr t))))) end ) in match (applyRec t args) with | None => (* Cannot apply [t] to [args] => continue *) cont () | Some result => (* Can apply [to] to [args], *) lazy_match! Constr.type result with | (forall _ : _, _) => (* but result would still accept an argument => continue *) cont () | _ => (* and nothing more can be applied to the result => we are done *) tac result end end . (* We have this double-primed version because we want to be able to feed it the proof before feeding it the ProofInfoLe. *)
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo

Γ ⊢i ϕ using i' → ProofInfoLe i' i → Γ ⊢i ϕ using i
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo

Γ ⊢i ϕ using i' → ProofInfoLe i' i → Γ ⊢i ϕ using i
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i

Γ ⊢i ϕ using i
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i

ProofInfoLe ?i' i
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i
Γ ⊢i ϕ using ?i'
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i

ProofInfoLe ?i' i
apply pile.
Σ: Signature
Γ: Theory
ϕ: Pattern
i', i: ProofInfo
H: Γ ⊢i ϕ using i'
pile: ProofInfoLe i' i

Γ ⊢i ϕ using i'
apply H. Defined. Ltac2 _callCompletedAndCast (t : constr) (tac : constr -> unit) := let tac' := (fun (t' : constr) => let tcast := open_constr:(@useGenericReasoning'' _ _ _ _ _ $t') in fillWithUnderscoresAndCall tac tcast [] ) in fillWithUnderscoresAndCall tac' t [] . Ltac2 try_solve_pile_basic () := Control.enter (fun () => lazy_match! goal with | [ |- (@ProofInfoLe _ _ _)] => try (solve [ apply pile_any | apply pile_refl | apply pile_basic_generic ]) | [|- _] => () end ) . Ltac2 try_wfa () := Control.enter (fun () => let wfa := (fun p => if (Constr.has_evar p) then () else ltac1:(try_wfauto2) ) in lazy_match! goal with | [|- well_formed ?p = true] => wfa p | [|- is_true (well_formed ?p) ] => wfa p | [|- Pattern.wf ?l = true] => wfa l | [|- is_true (Pattern.wf ?l) ] => wfa l | [|- _] => () end ) . Ltac2 mlApplyMeta (t : constr) := _callCompletedAndCast t _mlApplyMetaRaw ; try_solve_pile_basic (); try_wfa () . Ltac2 mlApplyMetaIn (t : constr) (name : constr) := _callCompletedAndCast t (fun t => _mlApplyMetaRawIn t name ); try_solve_pile_basic (); try_wfa () . Ltac _mlApplyMeta t := _ensureProofMode; let ff := ltac2:(t' |- mlApplyMeta (Option.get (Ltac1.to_constr(t')))) in ff t. Ltac _mlApplyMetaIn t name := _ensureProofMode; let ff := ltac2:(t' name' |- mlApplyMetaIn (Option.get (Ltac1.to_constr(t'))) (Option.get (Ltac1.to_constr(name')))) in ff t name . Tactic Notation "mlApplyMeta" constr(t) := _mlApplyMeta t. Tactic Notation "mlApplyMeta" constr(t) "in" constr(name) := _mlApplyMetaIn t name .
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo

Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i → Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo

Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i → Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i

Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))

mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))
wfg': well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))

mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))
wfg': well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf': Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))

mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))

well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))

Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i → well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))
Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))

Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i → well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) → mlTheory (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )
auto.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed (mlConclusion (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i ))
Hwf: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i )))

Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))

Γ Ⱶ l₁ ++ (nxy ∶ x and y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
l1: list named_hypothesis
Heql1: l1 = take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)
l2: list named_hypothesis
Heql2: l2 = drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)

well_formed y
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
Hwf0: well_formed y
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf: Pattern.wf (patterns_of (l₁ ++ (nxy ∶ x and y) :: l₂))
Hwf0: well_formed y
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
l1: list named_hypothesis
Heql1: l1 = take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)
l2: list named_hypothesis
Heql2: l2 = drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

well_formed y
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
l1: list named_hypothesis
Heql1: l1 = take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)
l2: list named_hypothesis
Heql2: l2 = drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

well_formed y
abstract ( apply wfapp_proj_2 in Hwf; unfold Pattern.wf in Hwf; simpl in Hwf; apply andb_prop in Hwf; destruct Hwf as [wfxy _]; wf_auto2 ).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ ?hyps-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

l₁ ++ (nxy ∶ x and y, ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (l₁ ++ (nxy ∶ x and y, ))
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

well_formed x
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

well_formed x
abstract ( apply wfapp_proj_2 in Hwf; unfold Pattern.wf in Hwf; simpl in Hwf; apply andb_prop in Hwf as [wfxy _]; wf_auto2 ).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x

Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x

Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- ?A and y using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
h: well_formed ?A → Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- y using i
well_formed ?A
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
H0: well_formed x
h: well_formed x → Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- y using i

well_formed x
wf_auto2.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Γ Ⱶ ?hyps-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) (l₁ ++ (nxy ∶ x and y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

l₁ ++ (nxy ∶ x and y, ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

patterns_of ?hyps = patterns_of ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))

Γ Ⱶ (l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
l1: list named_hypothesis
Heql1: l1 = take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)
l2: list named_hypothesis
Heql2: l2 = drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)

well_formed x
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
l1: list named_hypothesis
Heql1: l1 = take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)
l2: list named_hypothesis
Heql2: l2 = drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)

well_formed x
abstract ( apply wfapp_proj_2 in Hwf; unfold Pattern.wf in Hwf; simpl in Hwf; apply andb_prop in Hwf; destruct Hwf as [wfxy _]; wf_auto2 ).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ ?hyps-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

l₁ ++ (nxy ∶ x and y, ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (l₁ ++ (nxy ∶ x and y, ))
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

well_formed x
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

well_formed x
abstract ( apply wfapp_proj_2 in Hwf; unfold Pattern.wf in Hwf; simpl in Hwf; apply andb_prop in Hwf as [wfxy _]; wf_auto2 ).
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x

Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- x using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x

Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- x and ?B using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
h: well_formed ?B → Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- x using i
well_formed ?B
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1, H0: well_formed x
h: well_formed y → Γ Ⱶ l₁ ++ (nxy ∶ x and y, )-------------------------------------- x using i

well_formed y
assumption.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂)-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ ?hyps-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

(l₁ ++ (nxy ∶ x and y, )) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

l₁ ++ (nxy ∶ x and y, ) ++ l₂ = l₁ ++ (nxy ∶ x and y) :: l₂
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (take (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of ((l₁ ++ (nxy ∶ x and y, )) ++ (nx ∶ x) :: drop (length (l₁ ++ (nxy ∶ x and y, ))) ((l₁ ++ (nxy ∶ x and y, )) ++ (ny ∶ y) :: l₂))
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of ((l₁ ++ (nxy ∶ x and y, )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂)
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ (l₁ ++ (nxy ∶ x and y, )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of ((l₁ ++ (nxy ∶ x and y, )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂)
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x
Γ Ⱶ ?hyps-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of ((l₁ ++ (nxy ∶ x and y, )) ++ (nx ∶ x) :: (ny ∶ y) :: l₂)
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

patterns_of ?hyps = patterns_of (l₁ ++ (nxy ∶ x and y, ) ++ (nx ∶ x) :: (ny ∶ y) :: l₂)
reflexivity.
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ l₁ ++ (nxy ∶ x and y, ) ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
Σ: Signature
Γ: Theory
g: Pattern
l₁, l₂: list named_hypothesis
nx: string
x: Pattern
ny: string
y: Pattern
nxy: string
i: ProofInfo
H: Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
wfg: well_formed g
Hwf0: well_formed y
Hwf: Pattern.wf (map nh_patt l₁ ++ map nh_patt ((nxy ∶ x and y) :: l₂))
Hwf1: well_formed x

Γ Ⱶ l₁ ++ (nx ∶ x) :: (ny ∶ y) :: l₂-------------------------------------- g using i
exact H. Defined. Tactic Notation "mlDestructAnd" constr(name) "as" constr(name1) constr(name2) := _ensureProofMode; _failIfUsed name1; _failIfUsed name2; eapply cast_proof_ml_hyps; f_equal; _mlReshapeHypsByName name; apply MLGoal_destructAnd with (nxy := name) (nx := name1) (ny := name2); _mlReshapeHypsBack. Tactic Notation "mlDestructAnd" constr(name) := _ensureProofMode; let hyps := _getHypNames in let name0 := eval cbv in (fresh hyps) in let name1 := eval cbv in (fresh (name0 :: hyps)) in mlDestructAnd name as name0 name1.
Σ: Signature
Γ: Theory
a, b, p, q: Pattern

well_formed a → well_formed b → well_formed p → well_formed q → Γ ⊢i p and q ---> a and b ---> q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern

well_formed a → well_formed b → well_formed p → well_formed q → Γ ⊢i p and q ---> a and b ---> q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ ⊢i p and q ---> a and b ---> q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

well_formed (p and q ---> a and b ---> q ---> a)
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q
Γ Ⱶ p and q ---> a and b ---> q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

well_formed (p and q ---> a and b ---> q ---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ Ⱶ p and q ---> a and b ---> q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ Ⱶ "H0" ∶ p and q, -------------------------------------- a and b ---> q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ Ⱶ "H0" ∶ p and q, "H1" ∶ a and b, -------------------------------------- q ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ Ⱶ "H0" ∶ p and q, "H1" ∶ a and b, "H2" ∶ q, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ Ⱶ "H0" ∶ p and q, "H3" ∶ a, "H4" ∶ b, "H2" ∶ q, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, p, q: Pattern
H: well_formed a
H0: well_formed b
H1: well_formed p
H2: well_formed q

Γ Ⱶ "0" ∶ p, "1" ∶ q, "H3" ∶ a, "H4" ∶ b, "H2" ∶ q, -------------------------------------- a using BasicReasoning
mlExact "H3". Defined.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' and q' ---> p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p and q ---> p' and q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p and q ---> p' and q')
wf_auto2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p and q, -------------------------------------- p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! (! p or ! q), -------------------------------------- ! (! p' or ! q') using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! (! p or ! q), "H1" ∶ ! p' or ! q', -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H1" ∶ ! p' or ! q', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H2" ∶ ! p', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H3" ∶ ! q', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H2" ∶ ! p', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H2" ∶ ! p', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! p' ---> ! p, "H0" ∶ ! p or ! q ---> ⊥, "H2" ∶ ! p', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! p' ---> ! p, "H0" ∶ ! p or ! q ---> ⊥, "H2" ∶ ! p', -------------------------------------- ! p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i ! p' ---> ! p using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! p' ---> ! p, "H0" ∶ ! p or ! q ---> ⊥, "H2" ∶ ! p', -------------------------------------- ! p' using i
mlExact "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H3" ∶ ! q', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p or ! q ---> ⊥, "H3" ∶ ! q', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! q' ---> ! q, "H0" ∶ ! p or ! q ---> ⊥, "H3" ∶ ! q', -------------------------------------- ! p or ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! q' ---> ! q, "H0" ∶ ! p or ! q ---> ⊥, "H3" ∶ ! q', -------------------------------------- ! q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i ! q' ---> ! q using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! q' ---> ! q, "H0" ∶ ! p or ! q ---> ⊥, "H3" ∶ ! q', -------------------------------------- ! q' using i
mlExact "H3".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p' and q' ---> p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p' and q' ---> p and q)
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p' and q' ---> p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p' and q' ---> p and q)
wf_auto2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p' and q' ---> p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', -------------------------------------- p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! (! p' or ! q'), -------------------------------------- ! (! p or ! q) using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! (! p' or ! q'), "H1" ∶ ! p or ! q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H1" ∶ ! p or ! q, -------------------------------------- ! p' or ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H2" ∶ ! p, -------------------------------------- ! p' or ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H3" ∶ ! q, -------------------------------------- ! p' or ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H2" ∶ ! p, -------------------------------------- ! p' or ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H2" ∶ ! p, -------------------------------------- ! p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i ! p ---> ! p' using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H2" ∶ ! p, -------------------------------------- ! p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i ! p ---> ! p' using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! p ---> ! p', "H0" ∶ ! p' or ! q' ---> ⊥, "H2" ∶ ! p, -------------------------------------- ! p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i ! p ---> ! p' using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ ! p ---> ! p', "H0" ∶ ! p' or ! q' ---> ⊥, "H2" ∶ ! p, -------------------------------------- ! p using i
mlExact "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H3" ∶ ! q, -------------------------------------- ! p' or ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H3" ∶ ! q, -------------------------------------- ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i ! q ---> ! q' using i

Γ Ⱶ "H0" ∶ ! p' or ! q' ---> ⊥, "H3" ∶ ! q, -------------------------------------- ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i ! q ---> ! q' using i

Γ Ⱶ "H1" ∶ ! q ---> ! q', "H0" ∶ ! p' or ! q' ---> ⊥, "H3" ∶ ! q, -------------------------------------- ! q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i ! q ---> ! q' using i

Γ Ⱶ "H1" ∶ ! q ---> ! q', "H0" ∶ ! p' or ! q' ---> ⊥, "H3" ∶ ! q, -------------------------------------- ! q using i
mlExact "H3". Defined.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ ⊢i p' or q' ---> p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p or q ---> p' or q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p or q ---> p' or q')
auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p or q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H2" ∶ q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p ---> p' using i
assumption.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q, -------------------------------------- q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i q ---> q' using i
assumption.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p' or q' ---> p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p' or q' ---> p or q)
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p' or q' ---> p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p' or q' ---> p or q)
auto.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p' or q' ---> p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' or q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H2" ∶ q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p' ---> p using i
assumption.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q', -------------------------------------- q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i q' ---> q using i
assumption. Defined.
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i (p ---> q) <---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i (p ---> q) <---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i (p ---> q) <---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i (p ---> q) ---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ ⊢i ! p or q ---> p ---> q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i (p ---> q) ---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed ((p ---> q) ---> ! p or q)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ (p ---> q) ---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed ((p ---> q) ---> ! p or q)
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ (p ---> q) ---> ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ p ---> q, -------------------------------------- ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H1" ∶ p or ! p, "H0" ∶ p ---> q, -------------------------------------- ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H2" ∶ p, "H0" ∶ p ---> q, -------------------------------------- ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ "H3" ∶ ! p, "H0" ∶ p ---> q, -------------------------------------- ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H2" ∶ p, "H0" ∶ p ---> q, -------------------------------------- ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H2" ∶ p, "H0" ∶ p ---> q, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H2" ∶ p, "H0" ∶ p ---> q, -------------------------------------- p using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H3" ∶ ! p, "H0" ∶ p ---> q, -------------------------------------- ! p or q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H3" ∶ ! p, "H0" ∶ p ---> q, -------------------------------------- ! p using BasicReasoning
mlExact "H3".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i ! p or q ---> p ---> q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed (! p or q ---> p ---> q)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ ! p or q ---> p ---> q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed (! p or q ---> p ---> q)
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ ! p or q ---> p ---> q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ ! p or q, -------------------------------------- p ---> q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ ! p or q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ ! ! p ---> q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ ! ! p ---> q, "H2" ∶ p, -------------------------------------- ! ! p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H0" ∶ ! ! p ---> q, "H2" ∶ p, -------------------------------------- p using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
p: Pattern

well_formed p → Γ ⊢i ⊥ <---> p and ! p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern

well_formed p → Γ ⊢i ⊥ <---> p and ! p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ ⊢i ⊥ <---> p and ! p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ ⊢i ⊥ ---> p and ! p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ ⊢i p and ! p ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ ⊢i ⊥ ---> p and ! p using BasicReasoning
apply bot_elim; auto.
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ ⊢i p and ! p ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ ⊢i ! (! p or ! ! p) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

well_formed (! (! p or ! ! p) ---> ⊥)
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p
Γ Ⱶ ! (! p or ! ! p) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

well_formed (! (! p or ! ! p) ---> ⊥)
wf_auto2.
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ Ⱶ ! (! p or ! ! p) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ Ⱶ "H0" ∶ ! (! p or ! ! p), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ Ⱶ "H0" ∶ ! p or ! ! p ---> ⊥, -------------------------------------- ! p or ! ! p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
wfp: well_formed p

Γ Ⱶ "H1" ∶ ! p or ! ! p, "H0" ∶ ! p or ! ! p ---> ⊥, -------------------------------------- ! p or ! ! p using BasicReasoning
mlExact "H1". Defined. Ltac mlExFalso := _ensureProofMode; mlApplyMeta bot_elim . Tactic Notation "mlDestructBot" constr(name') := _ensureProofMode; _mlReshapeHypsByName name'; mlExFalso; mlExact name'; _mlReshapeHypsBack.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern

well_formed A → well_formed B → well_formed L → well_formed R → Γ ⊢i (L and A ---> B or R) ---> L ---> (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern

well_formed A → well_formed B → well_formed L → well_formed R → Γ ⊢i (L and A ---> B or R) ---> L ---> (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ ⊢i (L and A ---> B or R) ---> L ---> (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

well_formed ((L and A ---> B or R) ---> L ---> (A ---> B) or R)
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ (L and A ---> B or R) ---> L ---> (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

well_formed ((L and A ---> B or R) ---> L ---> (A ---> B) or R)
wf_auto2.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ (L and A ---> B or R) ---> L ---> (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H0" ∶ L and A ---> B or R, -------------------------------------- L ---> (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H2" ∶ A or ! A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Γ Ⱶ "H4" ∶ ! A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

well_formed (B or R)
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- B or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ B or R, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

well_formed (B or R)
wf_auto2.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- B or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ B or R, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- B or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- L and A using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- ! (! L or ! A) using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ ! L or ! A, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ ! L, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H5" ∶ ! A, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ ! L, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ L ---> ⊥, -------------------------------------- L using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H5" ∶ ! A, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H5" ∶ A ---> ⊥, -------------------------------------- A using BasicReasoning
mlExact "H3".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ B or R, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ B, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)
Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H5" ∶ R, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ B, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ B, -------------------------------------- A ---> B using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H4" ∶ B, "H2" ∶ A, -------------------------------------- B using BasicReasoning
mlExact "H4".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H5" ∶ R, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R
Hwf: well_formed (B or R)

Γ Ⱶ "H3" ∶ A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H5" ∶ R, -------------------------------------- R using BasicReasoning
mlExact "H5".
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H4" ∶ ! A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- (A ---> B) or R using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H4" ∶ ! A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, -------------------------------------- A ---> B using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H4" ∶ ! A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ A, -------------------------------------- B using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H4" ∶ ! A, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ A, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
wfA: well_formed A
wfB: well_formed B
wfL: well_formed L
wfR: well_formed R

Γ Ⱶ "H4" ∶ A ---> ⊥, "H0" ∶ L and A ---> B or R, "H1" ∶ L, "H2" ∶ A, -------------------------------------- A using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed L → well_formed R → Γ ⊢i L and A ---> B or R using i → Γ ⊢i L ---> (A ---> B) or R using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed L → well_formed R → Γ ⊢i L and A ---> B or R using i → Γ ⊢i L ---> (A ---> B) or R using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i

Γ ⊢i L ---> (A ---> B) or R using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i
Γ ⊢i ?ϕ₁ ---> L ---> (A ---> B) or R using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i

Γ ⊢i ?ϕ₁ ---> L ---> (A ---> B) or R using i
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i

Γ ⊢i ?ϕ₁ ---> L ---> (A ---> B) or R using BasicReasoning
apply weird_lemma; assumption.
Σ: Signature
Γ: Theory
A, B, L, R: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFL: well_formed L
WFR: well_formed R
H: Γ ⊢i L and A ---> B or R using i

Γ ⊢i L and A ---> B or R using i
exact H. Defined.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed C → well_formed D → Γ ⊢i C ---> A using i → Γ ⊢i B ---> D using i → Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed C → well_formed D → Γ ⊢i C ---> A using i → Γ ⊢i B ---> D using i → Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D using BasicReasoning

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D using ?i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using ?i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D using ?i
Γ ⊢i B ---> D using ?i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (B ---> D) ---> (A ---> B) ---> A ---> D using ?i

Γ ⊢i B ---> D using ?i
exact H0.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D using BasicReasoning

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D using ?i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using ?i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D using ?i
Γ ⊢i C ---> A using ?i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (C ---> A) ---> (A ---> D) ---> C ---> D using ?i

Γ ⊢i C ---> A using ?i
exact H.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i

Γ ⊢i (A ---> B) ---> C ---> D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
H3: Γ ⊢i (A ---> B) ---> C ---> D using i

Γ ⊢i (A ---> B) ---> C ---> D using i
exact H3.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i

well_formed (A ---> B)
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
well_formed (A ---> D)
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i C ---> A using i
H0: Γ ⊢i B ---> D using i
H1: Γ ⊢i (A ---> B) ---> A ---> D using i
H2: Γ ⊢i (A ---> D) ---> C ---> D using i
well_formed (C ---> D)
all: wf_auto2. Defined.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i B ---> C using i → Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i B ---> C using i → Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i

Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ ---> A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁ ---> A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁ ---> A and B ---> A and C using BasicReasoning
exact H0.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

Γ ⊢i A ---> B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
well_formed (A and C)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
Γ ⊢i B ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning

Γ ⊢i B ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i B ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁ ---> B ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁0 using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning
Γ ⊢i ?ϕ₁0 ---> ?ϕ₁ ---> B ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁0 ---> ?ϕ₁ ---> B ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i ?ϕ₁0 ---> ?ϕ₁ ---> B ---> A ---> A and C using BasicReasoning
exact H1.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i C ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning
Γ ⊢i B ---> C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i B ---> C using i
exact H.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i C ---> A ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
H1: Γ ⊢i (B ---> C) ---> (C ---> A ---> A and C) ---> B ---> A ---> A and C using BasicReasoning

Γ ⊢i C ---> A ---> A and C using BasicReasoning
apply conj_intro2; assumption.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i

well_formed A
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
well_formed (A and C)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
well_formed C
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
well_formed B
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i B ---> C using i
H0: Γ ⊢i (A ---> B ---> A and C) ---> A and B ---> A and C using BasicReasoning
well_formed (A ---> A and C)
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed C → well_formed D → Γ ⊢i A ---> B using i → Γ ⊢i C ---> D using i → Γ ⊢i A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo

well_formed A → well_formed B → well_formed C → well_formed D → Γ ⊢i A ---> B using i → Γ ⊢i C ---> D using i → Γ ⊢i A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ ⊢i A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

well_formed (A and C ---> B and D)
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

well_formed (A and C ---> B and D)
wf_auto2.
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H0" ∶ A ---> B, -------------------------------------- A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, -------------------------------------- A and C ---> B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H2" ∶ A and C, -------------------------------------- B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, -------------------------------------- B and D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H5" ∶ ! B or ! D, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H6" ∶ ! B, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i
Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H7" ∶ ! D, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H6" ∶ ! B, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H6" ∶ B ---> ⊥, -------------------------------------- B using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H6" ∶ B ---> ⊥, -------------------------------------- A using i
mlExact "H3".
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H7" ∶ ! D, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H7" ∶ ! D, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H7" ∶ D ---> ⊥, -------------------------------------- D using i
Σ: Signature
Γ: Theory
A, B, C, D: Pattern
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
WFD: well_formed D
H: Γ ⊢i A ---> B using i
H0: Γ ⊢i C ---> D using i

Γ Ⱶ "H1" ∶ C ---> D, "H0" ∶ A ---> B, "H3" ∶ A, "H4" ∶ C, "H7" ∶ D ---> ⊥, -------------------------------------- C using i
mlExact "H4". } } Defined.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A and B ---> C using i → Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo

well_formed A → well_formed B → well_formed C → Γ ⊢i A and B ---> C using i → Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ ⊢i A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

well_formed (A and B ---> A and C)
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

well_formed (A and B ---> A and C)
wf_auto2.
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, -------------------------------------- A and B ---> A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, -------------------------------------- A and C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H2" ∶ ! A or ! C, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H3" ∶ ! A, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i
Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H4" ∶ ! C, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H3" ∶ ! A, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H5" ∶ A, "H6" ∶ B, "H3" ∶ ! A, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H5" ∶ A, "H6" ∶ B, "H3" ∶ A ---> ⊥, -------------------------------------- A using i
mlExact "H5".
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H4" ∶ ! C, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H4" ∶ ! C, -------------------------------------- ⊥ using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H4" ∶ C ---> ⊥, -------------------------------------- C using i
Σ: Signature
A, B, C: Pattern
Γ: Theory
i: ProofInfo
WFA: well_formed A
WFB: well_formed B
WFC: well_formed C
H: Γ ⊢i A and B ---> C using i

Γ Ⱶ "H0" ∶ A and B ---> C, "H1" ∶ A and B, "H4" ∶ C ---> ⊥, -------------------------------------- A and B using i
mlExact "H1". } Defined.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo

well_formed a = true → well_formed b = true → well_formed a' = true → well_formed b' = true → Γ ⊢i a <---> a' using i → Γ ⊢i b <---> b' using i → Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo

well_formed a = true → well_formed b = true → well_formed a' = true → well_formed b' = true → Γ ⊢i a <---> a' using i → Γ ⊢i b <---> b' using i → Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i

Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i

well_formed (a ---> a')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i

well_formed (a ---> a')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i

well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i

well_formed (a' ---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i

Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i

well_formed (a ---> a')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i

well_formed (a ---> a')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i

well_formed (a' ---> a)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i

well_formed (a' ---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i

Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i

well_formed (b ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i

well_formed (b ---> b')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i

well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i

well_formed (b' ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i

Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i

well_formed (b ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i

well_formed (b ---> b')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i

well_formed (b' ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i

well_formed (b' ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b) <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed (a ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed (a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed (a' ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) <---> (a ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b) <---> (a ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b) <---> (a ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b) ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a ---> b') ---> a ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b) ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b) ---> a ---> b')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ (a ---> b) ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a ---> b, -------------------------------------- a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a ---> b, "H1" ∶ a, -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ b ---> b', "H0" ∶ a ---> b, "H1" ∶ a, -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ b ---> b', "H0" ∶ a ---> b, "H1" ∶ a, -------------------------------------- b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ b ---> b', "H0" ∶ a ---> b, "H1" ∶ a, -------------------------------------- a using i
mlExact "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b') ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b') ---> a ---> b)
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ (a ---> b') ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b') ---> a ---> b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ (a ---> b') ---> a ---> b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a ---> b', -------------------------------------- a ---> b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a ---> b', "H1" ∶ a, -------------------------------------- b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ b' ---> b, "H0" ∶ a ---> b', "H1" ∶ a, -------------------------------------- b using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ b' ---> b, "H0" ∶ a ---> b', "H1" ∶ a, -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ b' ---> b, "H0" ∶ a ---> b', "H1" ∶ a, -------------------------------------- a using i
mlExact "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b') <---> (a' ---> b') using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b') ---> a' ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
well_formed ((a' ---> b') ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a' ---> b') ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ ⊢i (a' ---> b') ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b') ---> a' ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a ---> b') ---> a' ---> b')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ (a ---> b') ---> a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a ---> b', -------------------------------------- a' ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a ---> b', "H1" ∶ a', -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ a' ---> a, "H0" ∶ a ---> b', "H1" ∶ a', -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ a' ---> a, "H0" ∶ a ---> b', "H1" ∶ a', -------------------------------------- a using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ a' ---> a, "H0" ∶ a ---> b', "H1" ∶ a', -------------------------------------- a' using i
mlExact "H1".
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ ⊢i (a' ---> b') ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a' ---> b') ---> a ---> b')
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i
Γ Ⱶ (a' ---> b') ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

well_formed ((a' ---> b') ---> a ---> b')
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ (a' ---> b') ---> a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a' ---> b', -------------------------------------- a ---> b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H0" ∶ a' ---> b', "H1" ∶ a, -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ a ---> a', "H0" ∶ a' ---> b', "H1" ∶ a, -------------------------------------- b' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ a ---> a', "H0" ∶ a' ---> b', "H1" ∶ a, -------------------------------------- a' using i
Σ: Signature
Γ: Theory
a, b, a', b': Pattern
i: ProofInfo
wfa: well_formed a = true
wfb: well_formed b = true
wfa': well_formed a' = true
wfb': well_formed b' = true
Haa': Γ ⊢i a <---> a' using i
Hbb': Γ ⊢i b <---> b' using i
Haa'1: Γ ⊢i a ---> a' using i
Haa'2: Γ ⊢i a' ---> a using i
Hbb'1: Γ ⊢i b ---> b' using i
Hbb'2: Γ ⊢i b' ---> b using i

Γ Ⱶ "H2" ∶ a ---> a', "H0" ∶ a' ---> b', "H1" ∶ a, -------------------------------------- a using i
mlExact "H1". Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a and b ---> c using i → Γ ⊢i a ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a and b ---> c using i → Γ ⊢i a ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ ⊢i a ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

well_formed (a ---> b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
Γ Ⱶ a ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

well_formed (a ---> b ---> c)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ Ⱶ a ---> b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ Ⱶ "H0" ∶ a, -------------------------------------- b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, -------------------------------------- a and b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ ⊢i a ---> b ---> a and b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

Γ ⊢i a ---> b ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

well_formed a
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a and b ---> c using i

well_formed b
wf_auto2. } Defined.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c using i → Γ ⊢i a and b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c using i → Γ ⊢i a and b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ ⊢i a and b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

well_formed (a and b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Γ Ⱶ a and b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

well_formed (a and b ---> c)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ Ⱶ a and b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

Γ Ⱶ "H0" ∶ a and b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ "H0" ∶ a and b, -------------------------------------- b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ "H0" ∶ a and b, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i

well_formed b
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

Γ Ⱶ "H0" ∶ a and b, -------------------------------------- b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Γ Ⱶ "H0" ∶ a and b, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

Γ Ⱶ "H0" ∶ a and b, -------------------------------------- b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

Γ ⊢i a and b ---> b using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

Γ ⊢i a and b ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
well_formed b
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

well_formed b
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b

Γ Ⱶ "H0" ∶ a and b, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a and b, )
l2: list named_hypothesis
Heql2: l2 = ("H1" ∶ b, )

well_formed a
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ "H0" ∶ a and b, -------------------------------------- a using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
l1: list named_hypothesis
Heql1: l1 = ("H0" ∶ a and b, )
l2: list named_hypothesis
Heql2: l2 = ("H1" ∶ b, )

well_formed a
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

Γ Ⱶ "H0" ∶ a and b, -------------------------------------- a using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Γ Ⱶ "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

Γ Ⱶ "H0" ∶ a and b, -------------------------------------- a using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

Γ ⊢i a and b ---> a using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

Γ ⊢i a and b ---> a using BasicReasoning
apply pf_conj_elim_l; wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

Γ Ⱶ "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

well_formed (b ---> c)
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, "H4" ∶ b ---> c, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a

well_formed (b ---> c)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)

Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)
Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, "H4" ∶ b ---> c, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)

Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- b ---> c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)

Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, -------------------------------------- a using i
mlExact "H2".
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)

Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, "H4" ∶ b ---> c, -------------------------------------- c using i
Σ: Signature
Γ: Theory
a, b, c: Pattern
i: ProofInfo
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
H: Γ ⊢i a ---> b ---> c using i
Hwf: well_formed b
Hwf0: well_formed a
Hwf1: well_formed (b ---> c)

Γ Ⱶ "H3" ∶ a ---> b ---> c, "H0" ∶ a and b, "H2" ∶ a, "H1" ∶ b, "H4" ∶ b ---> c, -------------------------------------- b using i
mlExact "H1". Defined.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern

well_formed a → well_formed b → Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern

well_formed a → well_formed b → Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf l

Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf []

Γ ⊢i foldr patt_imp a [] ---> foldr patt_imp b [] ---> foldr patt_imp (a and b) [] using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
Γ ⊢i foldr patt_imp a (a0 :: l) ---> foldr patt_imp b (a0 :: l) ---> foldr patt_imp (a and b) (a0 :: l) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf []

Γ ⊢i foldr patt_imp a [] ---> foldr patt_imp b [] ---> foldr patt_imp (a and b) [] using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf []

Γ ⊢i a ---> b ---> a and b using BasicReasoning
apply conj_intro; assumption.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning

Γ ⊢i foldr patt_imp a (a0 :: l) ---> foldr patt_imp b (a0 :: l) ---> foldr patt_imp (a and b) (a0 :: l) using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning

Γ ⊢i (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfl': Pattern.wf (a0 :: l)

Γ ⊢i (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfl': foldr andb true (map well_formed (a0 :: l))

Γ ⊢i (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfl': well_formed a0 && foldr andb true (map well_formed l)

Γ ⊢i (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

Γ ⊢i (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

Γ ⊢i (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

well_formed ((a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l)
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

well_formed ((a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ (a0 ---> foldr patt_imp a l) ---> (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, -------------------------------------- (a0 ---> foldr patt_imp b l) ---> a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, -------------------------------------- a0 ---> foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

well_formed (foldr patt_imp a l)
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, -------------------------------------- foldr patt_imp a l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true

well_formed (foldr patt_imp a l)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, -------------------------------------- foldr patt_imp a l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, -------------------------------------- foldr patt_imp a l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, -------------------------------------- a0 using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)

well_formed (foldr patt_imp b l)
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- foldr patt_imp b l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, "H4" ∶ foldr patt_imp b l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)

well_formed (foldr patt_imp b l)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- foldr patt_imp b l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)
Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, "H4" ∶ foldr patt_imp b l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- foldr patt_imp b l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, -------------------------------------- a0 using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H2" ∶ a0, "H3" ∶ foldr patt_imp a l, "H4" ∶ foldr patt_imp b l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H1" ∶ a0 ---> foldr patt_imp b l, "H3" ∶ foldr patt_imp a l, "H4" ∶ foldr patt_imp b l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H0" ∶ a0 ---> foldr patt_imp a l, "H3" ∶ foldr patt_imp a l, "H4" ∶ foldr patt_imp b l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ Ⱶ "H3" ∶ foldr patt_imp a l, "H4" ∶ foldr patt_imp b l, -------------------------------------- foldr patt_imp (a and b) l using BasicReasoning
Σ: Signature
Γ: Theory
a, b, a0: Pattern
l: list Pattern
wfa: well_formed a
wfb: well_formed b
wfl: Pattern.wf (a0 :: l)
IHl: Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
wfa0: well_formed a0 = true
wfl': foldr andb true (map well_formed l) = true
Hwf: well_formed (foldr patt_imp a l)
Hwf0: well_formed (foldr patt_imp b l)

Γ ⊢i foldr patt_imp a l ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
apply IHl. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo

well_formed a → well_formed b → Pattern.wf l → Γ ⊢i foldr patt_imp a l using i → Γ ⊢i foldr patt_imp b l ---> foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo

well_formed a → well_formed b → Pattern.wf l → Γ ⊢i foldr patt_imp a l using i → Γ ⊢i foldr patt_imp b l ---> foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i

Γ ⊢i foldr patt_imp b l ---> foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp b l ---> foldr patt_imp (a and b) l using BasicReasoning
apply prf_conj_split; assumption.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i

Γ ⊢i foldr patt_imp a l using i
exact H2. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo

well_formed a → well_formed b → Pattern.wf l → Γ ⊢i foldr patt_imp a l using i → Γ ⊢i foldr patt_imp b l using i → Γ ⊢i foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo

well_formed a → well_formed b → Pattern.wf l → Γ ⊢i foldr patt_imp a l using i → Γ ⊢i foldr patt_imp b l using i → Γ ⊢i foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i

Γ ⊢i foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp (a and b) l using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp (a and b) l using i
apply prf_conj_split_meta; assumption.
Σ: Signature
Γ: Theory
a, b: Pattern
l: list Pattern
i: ProofInfo
H: well_formed a
H0: well_formed b
H1: Pattern.wf l
H2: Γ ⊢i foldr patt_imp a l using i
H3: Γ ⊢i foldr patt_imp b l using i

Γ ⊢i foldr patt_imp b l using i
exact H3. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo

Γ Ⱶ l-------------------------------------- a using i → Γ Ⱶ l-------------------------------------- b using i → Γ Ⱶ l-------------------------------------- a and b using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo

Γ Ⱶ l-------------------------------------- a using i → Γ Ⱶ l-------------------------------------- b using i → Γ Ⱶ l-------------------------------------- a and b using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ Ⱶ l-------------------------------------- a using i
Hb: Γ Ⱶ l-------------------------------------- b using i

Γ Ⱶ l-------------------------------------- a and b using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- a using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- a using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- a using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- a using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- a using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- a using i )
Hb: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- b using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- b using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- b using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- b using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- b using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- b using i )

well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- a and b using i )) → Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- a and b using i ))) → mlTheory (Γ Ⱶ l-------------------------------------- a and b using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- a and b using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- a and b using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- a and b using i )
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i

well_formed (a and b) → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed a
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed a
abstract(wf_auto2).
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: well_formed a → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
exact wfl.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed b
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed b
abstract(wf_auto2).
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: well_formed b → Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Pattern.wf (patterns_of l)
exact wfl.
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp (a and b) (patterns_of l) using i
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed a
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)
well_formed b
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed a
abstract (wf_auto2).
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed b
Σ: Signature
Γ: Theory
a, b: Pattern
l: hypotheses
i: ProofInfo
Ha: Γ ⊢i foldr patt_imp a (patterns_of l) using i
Hb: Γ ⊢i foldr patt_imp b (patterns_of l) using i
wfab: well_formed (a and b)
wfl: Pattern.wf (patterns_of l)

well_formed b
abstract (wf_auto2). } Defined. Ltac mlSplitAnd := _ensureProofMode; apply MLGoal_splitAnd .
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern

well_formed a → well_formed b → well_formed c → Γ ⊢i a ---> b ---> c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ ⊢i a ---> b ---> c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

well_formed (a ---> b ---> c ---> a and b)
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ a ---> b ---> c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

well_formed (a ---> b ---> c ---> a and b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ a ---> b ---> c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, -------------------------------------- b ---> c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, -------------------------------------- c ---> a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, "H2" ∶ c, -------------------------------------- a and b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, "H2" ∶ c, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c
Γ Ⱶ "H0" ∶ a, "H1" ∶ b, "H2" ∶ c, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, "H2" ∶ c, -------------------------------------- a using BasicReasoning
mlExact "H0".
Σ: Signature
Γ: Theory
a, b, c: Pattern
wfa: well_formed a
wfb: well_formed b
wfc: well_formed c

Γ Ⱶ "H0" ∶ a, "H1" ∶ b, "H2" ∶ c, -------------------------------------- b using BasicReasoning
mlExact "H1". Defined.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l

Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf []

Γ ⊢i g₁ <---> g₂ ---> g₁ <---> g₂ using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf []

Γ ⊢i g₁ <---> g₂ ---> g₁ <---> g₂ using BasicReasoning
apply A_impl_A; wf_auto2.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning

Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfl': Pattern.wf (a :: l)

Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfl': foldr andb true (map well_formed (a :: l))

Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfl': well_formed a && foldr andb true (map well_formed l)

Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ ⊢i (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

well_formed ((a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l))
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

well_formed ((a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l))
wf_auto2.
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- (a ---> foldr patt_imp g₁ l) <---> (a ---> foldr patt_imp g₂ l) using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- (a ---> foldr patt_imp g₁ l) ---> a ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true
Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- (a ---> foldr patt_imp g₂ l) ---> a ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- (a ---> foldr patt_imp g₁ l) ---> a ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- a ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> a ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ a ---> foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a, -------------------------------------- foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ foldr patt_imp g₁ l <---> foldr patt_imp g₂ l, -------------------------------------- foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ (foldr patt_imp g₁ l ---> foldr patt_imp g₂ l) and (foldr patt_imp g₂ l ---> foldr patt_imp g₁ l), -------------------------------------- foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H1" ∶ foldr patt_imp g₁ l ---> foldr patt_imp g₂ l, "H2" ∶ foldr patt_imp g₂ l ---> foldr patt_imp g₁ l, -------------------------------------- foldr patt_imp g₁ l ---> foldr patt_imp g₂ l using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- (a ---> foldr patt_imp g₂ l) ---> a ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a ---> foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- a ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ (a ---> foldr patt_imp (g₁ <---> g₂) l) ---> a ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ a ---> foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ a, -------------------------------------- foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ foldr patt_imp (g₁ <---> g₂) l, -------------------------------------- foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ foldr patt_imp g₁ l <---> foldr patt_imp g₂ l, -------------------------------------- foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H0" ∶ (foldr patt_imp g₁ l ---> foldr patt_imp g₂ l) and (foldr patt_imp g₂ l ---> foldr patt_imp g₁ l), -------------------------------------- foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
Σ: Signature
Γ: Theory
g₁, g₂, a: Pattern
l: list Pattern
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf (a :: l)
IHl: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
wfa: well_formed a = true
wfl': foldr andb true (map well_formed l) = true

Γ Ⱶ "H1" ∶ foldr patt_imp g₁ l ---> foldr patt_imp g₂ l, "H2" ∶ foldr patt_imp g₂ l ---> foldr patt_imp g₁ l, -------------------------------------- foldr patt_imp g₂ l ---> foldr patt_imp g₁ l using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i → Γ ⊢i foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i → Γ ⊢i foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i

Γ ⊢i foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₁ l <---> foldr patt_imp g₂ l using BasicReasoning
apply prf_local_goals_equiv_impl_full_equiv; assumption.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i

Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
exact H. Defined.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i → Γ ⊢i foldr patt_imp g₁ l using i → Γ ⊢i foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i → Γ ⊢i foldr patt_imp g₁ l using i → Γ ⊢i foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i

Γ ⊢i foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i ?ϕ₁ <---> foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i

Γ ⊢i foldr patt_imp ?g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp ?g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed ?g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Pattern.wf l
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Γ ⊢i foldr patt_imp (?g₁ <---> g₂) l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i

Γ ⊢i foldr patt_imp g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Pattern.wf l
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i

well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₁ l using i
Pattern.wf l
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i → Γ ⊢i foldr patt_imp g₂ l using i → Γ ⊢i foldr patt_imp g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo

well_formed g₁ → well_formed g₂ → Pattern.wf l → Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i → Γ ⊢i foldr patt_imp g₂ l using i → Γ ⊢i foldr patt_imp g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i

Γ ⊢i foldr patt_imp g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g₁ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed ?ϕ₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp g₁ l <---> ?ϕ₁ using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i

Γ ⊢i foldr patt_imp ?g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp ?g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed ?g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Pattern.wf l
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Γ ⊢i foldr patt_imp (g₁ <---> ?g₂) l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i

Γ ⊢i foldr patt_imp g₂ l using i
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Pattern.wf l
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i

well_formed (foldr patt_imp g₁ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed (foldr patt_imp g₂ l)
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₁
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
well_formed g₂
Σ: Signature
Γ: Theory
g₁, g₂: Pattern
l: list Pattern
i: ProofInfo
wfg₁: well_formed g₁
wfg₂: well_formed g₂
wfl: Pattern.wf l
H1: Γ ⊢i foldr patt_imp (g₁ <---> g₂) l using i
H2: Γ ⊢i foldr patt_imp g₂ l using i
Pattern.wf l
all: wf_auto2. Defined.
Σ: Signature
Γ: Theory

Γ ⊢i Top using BasicReasoning
Σ: Signature
Γ: Theory

Γ ⊢i Top using BasicReasoning
Σ: Signature
Γ: Theory

well_formed ⊥
Σ: Signature
Γ: Theory

well_formed ⊥
wf_auto2. } Defined.
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ϕ <---> (ϕ <---> Top) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ϕ <---> (ϕ <---> Top) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i ϕ <---> (ϕ <---> Top) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (ϕ <---> (ϕ <---> Top))
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ ϕ <---> (ϕ <---> Top) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (ϕ <---> (ϕ <---> Top))
wf_auto2.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ϕ <---> (ϕ <---> Top) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- ϕ <---> Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ "H0" ∶ ϕ <---> Top, -------------------------------------- ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- ϕ <---> Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- ϕ ---> Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- Top ---> ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- ϕ ---> Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, "H1" ∶ ϕ, -------------------------------------- Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i Top using BasicReasoning
apply top_holds. (* TODO: we need something like [mlExactMeta top_holds] *)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ, -------------------------------------- Top ---> ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i ϕ ---> Top ---> ϕ using BasicReasoning
apply P1; wf_auto2.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ <---> Top, -------------------------------------- ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H1" ∶ ϕ ---> Top, "H2" ∶ Top ---> ϕ, -------------------------------------- ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H1" ∶ ϕ ---> Top, "H2" ∶ Top ---> ϕ, -------------------------------------- Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H1" ∶ ϕ ---> Top, -------------------------------------- Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ Top using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i Top using BasicReasoning
apply top_holds. Defined.
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢i ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (! ϕ <---> (ϕ <---> ⊥))
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (! ϕ <---> (ϕ <---> ⊥))
wf_auto2.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ! ϕ <---> (ϕ <---> ⊥) using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ! ϕ, -------------------------------------- ϕ <---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ "H0" ∶ ϕ <---> ⊥, -------------------------------------- ! ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ! ϕ, -------------------------------------- ϕ <---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ! ϕ, -------------------------------------- ϕ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ "H0" ∶ ! ϕ, -------------------------------------- ⊥ ---> ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ! ϕ, -------------------------------------- ϕ ---> ⊥ using BasicReasoning
mlExact "H0".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ! ϕ, -------------------------------------- ⊥ ---> ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ⊥ ---> ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i ⊥ ---> ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed ϕ
wf_auto2. }
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H0" ∶ ϕ <---> ⊥, -------------------------------------- ! ϕ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H1" ∶ ϕ ---> ⊥, "H2" ∶ ⊥ ---> ϕ, -------------------------------------- ! ϕ using BasicReasoning
mlExact "H1". Defined.
Σ: Signature
Γ: Theory
A: Pattern

well_formed A → Γ ⊢i A <---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern

well_formed A → Γ ⊢i A <---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i A <---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed A
wf_auto2.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed (! ! A)
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed (! ! A)
wf_auto2.
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A
Γ ⊢i ! ! A ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i A ---> ! ! A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed A
wf_auto2. }
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

Γ ⊢i ! ! A ---> A using BasicReasoning
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed A
Σ: Signature
Γ: Theory
A: Pattern
wfA: well_formed A

well_formed A
wf_auto2. } Defined.
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i p and q <---> q and p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern

well_formed p → well_formed q → Γ ⊢i p and q <---> q and p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ ⊢i p and q <---> q and p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed (p and q <---> q and p)
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ p and q <---> q and p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

well_formed (p and q <---> q and p)
wf_auto2.
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ p and q <---> q and p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ "H1" ∶ q, "H2" ∶ p, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q
Γ Ⱶ "H1" ∶ q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- q using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- p using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H1" ∶ q, "H2" ∶ p, -------------------------------------- p using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
p, q: Pattern
wfp: well_formed p
wfq: well_formed q

Γ Ⱶ "H1" ∶ q, "H2" ∶ p, -------------------------------------- q using BasicReasoning
mlExact "H1". Defined. (* We need to come up with tactics that make this easier. *)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern

well_formed ϕ₁ → well_formed ϕ₂ → Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern

well_formed ϕ₁ → well_formed ϕ₂ → Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

Γ ⊢i (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

well_formed ((! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Γ Ⱶ (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

well_formed ((! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁)
wf_auto2.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

Γ Ⱶ (! ϕ₁ ---> ! ϕ₂) ---> ϕ₂ ---> ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

Γ Ⱶ "H0" ∶ ! ϕ₁ ---> ! ϕ₂, -------------------------------------- ϕ₂ ---> ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

Γ Ⱶ "H0" ∶ ! ϕ₁ ---> ! ϕ₂, "H1" ∶ ϕ₂, -------------------------------------- ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, -------------------------------------- ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, -------------------------------------- (ϕ₁ ---> ⊥) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥, -------------------------------------- ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂

well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
wf_auto2.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, -------------------------------------- (ϕ₁ ---> ⊥) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥, -------------------------------------- ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, -------------------------------------- (ϕ₁ ---> ⊥) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

well_formed (ϕ₂ ---> ⊥)
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, -------------------------------------- ϕ₂ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, "H3" ∶ ϕ₂ ---> ⊥, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

well_formed (ϕ₂ ---> ⊥)
wf_auto2.
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, -------------------------------------- ϕ₂ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)
Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, "H3" ∶ ϕ₂ ---> ⊥, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, -------------------------------------- ϕ₂ ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, -------------------------------------- ϕ₁ ---> ⊥ using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, "H3" ∶ ϕ₂ ---> ⊥, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)
Hwf0: well_formed (ϕ₂ ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ ϕ₁ ---> ⊥, "H3" ∶ ϕ₂ ---> ⊥, -------------------------------------- ϕ₂ using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥, -------------------------------------- ϕ₁ using BasicReasoning
Σ: Signature
Γ: Theory
ϕ₁, ϕ₂: Pattern
wfϕ₁: well_formed ϕ₁
wfϕ₂: well_formed ϕ₂
Hwf: well_formed ((ϕ₁ ---> ⊥) ---> ⊥)

Γ Ⱶ "H0" ∶ (ϕ₁ ---> ⊥) ---> ϕ₂ ---> ⊥, "H1" ∶ ϕ₂, "H2" ∶ (ϕ₁ ---> ⊥) ---> ⊥, -------------------------------------- ! ! ϕ₁ using BasicReasoning
mlExact "H2". Defined.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs

Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

well_formed (x ---> g)
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

well_formed (x ---> g)
wf_auto2. }
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: well_formed a && foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> foldr patt_imp g (x :: xs) using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ ⊢i (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed ((a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed ((a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ (a and foldr patt_and x xs ---> g) ---> x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, -------------------------------------- x ---> a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, -------------------------------------- a ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, -------------------------------------- (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H4" ∶ (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, -------------------------------------- (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H4" ∶ (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, -------------------------------------- (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

well_formed (x ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, "H6" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

well_formed (x ---> foldr patt_imp g xs)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, "H6" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, -------------------------------------- foldr patt_and x xs ---> g using BasicReasoning
mlExact "H5".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, "H6" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, "H6" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Hwf0: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H1" ∶ x, "H2" ∶ a, "H5" ∶ foldr patt_and x xs ---> g, "H6" ∶ x ---> foldr patt_imp g xs, -------------------------------------- x using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H3" ∶ (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs, "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H4" ∶ (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H4" ∶ (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs, -------------------------------------- foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H4" ∶ (foldr patt_and x xs ---> g) ---> foldr patt_imp g xs, -------------------------------------- foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, -------------------------------------- foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H3" ∶ foldr patt_and x xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H3" ∶ foldr patt_and x xs, -------------------------------------- a and foldr patt_and x xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H3" ∶ foldr patt_and x xs, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)
Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H3" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and x xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H3" ∶ foldr patt_and x xs, -------------------------------------- a using BasicReasoning
mlExact "H2".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (foldr patt_and x xs ---> g) ---> x ---> foldr patt_imp g xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed ((foldr patt_and x xs ---> g) ---> foldr patt_imp g xs)

Γ Ⱶ "H0" ∶ a and foldr patt_and x xs ---> g, "H1" ∶ x, "H2" ∶ a, "H3" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and x xs using BasicReasoning
mlExact "H3". Defined.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> g using i → Γ ⊢i foldr patt_imp g (x :: xs) using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> g using i → Γ ⊢i foldr patt_imp g (x :: xs) using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i

Γ ⊢i foldr patt_imp g (x :: xs) using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i
Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (x :: xs) using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (x :: xs) using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i

Γ ⊢i ?ϕ₁ ---> foldr patt_imp g (x :: xs) using BasicReasoning
apply lhs_and_to_imp; assumption.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_and x xs ---> g using i

Γ ⊢i foldr patt_and x xs ---> g using i
exact H. Defined.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs

Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

Γ ⊢i (x ---> g) ---> x ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x: Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf []

well_formed (x ---> g)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfxs: well_formed a && foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_imp g (x :: xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ ⊢i (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed ((x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Γ Ⱶ (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed ((x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, -------------------------------------- (x ---> a ---> foldr patt_imp g xs) ---> a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ x ---> a ---> foldr patt_imp g xs, -------------------------------------- a and foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ x ---> a ---> foldr patt_imp g xs, "H2" ∶ a and foldr patt_and x xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ x ---> a ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed (x ---> foldr patt_imp g xs)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)

well_formed (x ---> foldr patt_imp g xs)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- a using BasicReasoning
mlExact "H3".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)

well_formed (foldr patt_and x xs ---> g)
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, "H6" ∶ foldr patt_and x xs ---> g, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)

well_formed (foldr patt_and x xs ---> g)
wf_auto2.
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)
Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, "H6" ∶ foldr patt_and x xs ---> g, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- foldr patt_and x xs ---> g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, -------------------------------------- x ---> foldr patt_imp g xs using BasicReasoning
mlExact "H5".
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, "H6" ∶ foldr patt_and x xs ---> g, -------------------------------------- g using BasicReasoning
Σ: Signature
Γ: Theory
g, x, a: Pattern
xs: list Pattern
wfg: well_formed g
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwffa: well_formed (foldr patt_and x xs)
Hwf: well_formed (x ---> foldr patt_imp g xs)
Hwf0: well_formed (foldr patt_and x xs ---> g)

Γ Ⱶ "H" ∶ (x ---> foldr patt_imp g xs) ---> foldr patt_and x xs ---> g, "H1" ∶ a ---> x ---> foldr patt_imp g xs, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "H5" ∶ x ---> foldr patt_imp g xs, "H6" ∶ foldr patt_and x xs ---> g, -------------------------------------- foldr patt_and x xs using BasicReasoning
mlExact "H4". } Defined.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) using i → Γ ⊢i foldr patt_and x xs ---> g using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo

well_formed g → well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_imp g (x :: xs) using i → Γ ⊢i foldr patt_and x xs ---> g using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i

Γ ⊢i foldr patt_and x xs ---> g using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i

Γ ⊢i ?ϕ₁ using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i
Γ ⊢i ?ϕ₁ ---> foldr patt_and x xs ---> g using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i

Γ ⊢i ?ϕ₁ ---> foldr patt_and x xs ---> g using i
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i

Γ ⊢i ?ϕ₁ ---> foldr patt_and x xs ---> g using BasicReasoning
apply lhs_imp_to_and; assumption.
Σ: Signature
Γ: Theory
g, x: Pattern
xs: list Pattern
i: ProofInfo
wfg: well_formed g
wfx: well_formed x
wfxs: Pattern.wf xs
H: Γ ⊢i foldr patt_imp g (x :: xs) using i

Γ ⊢i foldr patt_imp g (x :: xs) using i
exact H. Defined.
Σ: Signature
Γ: Theory
x: Pattern
xs: list Pattern

well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x: Pattern
xs: list Pattern

well_formed x → Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf xs

Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x: Pattern
wfx: well_formed x
wfxs: Pattern.wf []

Γ ⊢i x ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x: Pattern
wfx: well_formed x
wfxs: Pattern.wf []

Γ ⊢i x ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x: Pattern
wfx: well_formed x
wfxs: Pattern.wf []

well_formed x
exact wfx.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfxs: well_formed a && foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

Γ ⊢i a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

well_formed (a and foldr patt_and x xs ---> x)
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)
Γ Ⱶ a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

well_formed (a and foldr patt_and x xs ---> x)
wf_auto2.
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

Γ Ⱶ a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

Γ Ⱶ "IH" ∶ foldr patt_and x xs ---> x, -------------------------------------- a and foldr patt_and x xs ---> x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

Γ Ⱶ "IH" ∶ foldr patt_and x xs ---> x, "H" ∶ a and foldr patt_and x xs, -------------------------------------- x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

Γ Ⱶ "IH" ∶ foldr patt_and x xs ---> x, "Ha" ∶ a, "Hf" ∶ foldr patt_and x xs, -------------------------------------- x using BasicReasoning
Σ: Signature
Γ: Theory
x, a: Pattern
xs: list Pattern
wfx: well_formed x
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i foldr patt_and x xs ---> x using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf2: well_formed (foldr patt_and x xs)

Γ Ⱶ "IH" ∶ foldr patt_and x xs ---> x, "Ha" ∶ a, "Hf" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and x xs using BasicReasoning
mlExact "Hf". } Defined.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern

well_formed x → well_formed y → Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern

well_formed x → well_formed y → Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs

Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y: Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf []

Γ ⊢i (x ---> y) ---> x ---> y using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y: Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf []

Γ ⊢i (x ---> y) ---> x ---> y using BasicReasoning
Σ: Signature
Γ: Theory
x, y: Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf []

well_formed (x ---> y)
wf_auto2.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf (a :: xs)
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: foldr andb true (map well_formed (a :: xs))
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfxs: well_formed a && foldr andb true (map well_formed xs)
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: foldr andb true (map well_formed xs) = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)

well_formed (foldr patt_and x xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)

well_formed (foldr patt_and y xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)

well_formed (foldr patt_and y xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Pattern.wf xs → Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ ⊢i (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

well_formed ((x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Γ Ⱶ (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

well_formed ((x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs)
wf_auto2.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ Ⱶ (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, -------------------------------------- (x ---> y) ---> a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, -------------------------------------- a and foldr patt_and x xs ---> a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H2" ∶ a and foldr patt_and x xs, -------------------------------------- a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- a and foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

well_formed (foldr patt_and x xs ---> foldr patt_and y xs)
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs, -------------------------------------- foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)

well_formed (foldr patt_and x xs ---> foldr patt_and y xs)
wf_auto2.
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)
Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs, -------------------------------------- foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, -------------------------------------- x ---> y using BasicReasoning
mlExact "H1".
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs, -------------------------------------- foldr patt_and y xs using BasicReasoning
Σ: Signature
Γ: Theory
x, y, a: Pattern
xs: list Pattern
wfx: well_formed x
wfy: well_formed y
wfa: well_formed a = true
wfxs: Pattern.wf xs = true
IHxs: Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
wfaxs: Pattern.wf (a :: xs)
Hwf1: well_formed (foldr patt_and x xs)
Hwf2: well_formed (foldr patt_and y xs)
Hwf: well_formed (foldr patt_and x xs ---> foldr patt_and y xs)

Γ Ⱶ "IH" ∶ (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs, "H1" ∶ x ---> y, "H3" ∶ a, "H4" ∶ foldr patt_and x xs, "IH'" ∶ foldr patt_and x xs ---> foldr patt_and y xs, -------------------------------------- foldr patt_and x xs using BasicReasoning
mlExact "H4". } Defined.
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo

well_formed x → well_formed y → Pattern.wf xs → Γ ⊢i x ---> y using i → Γ ⊢i foldr patt_and x xs ---> foldr patt_and y xs using i
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo

well_formed x → well_formed y → Pattern.wf xs → Γ ⊢i x ---> y using i → Γ ⊢i foldr patt_and x xs ---> foldr patt_and y xs using i
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
H: Γ ⊢i x ---> y using i

Γ ⊢i foldr patt_and x xs ---> foldr patt_and y xs using i
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
H: Γ ⊢i x ---> y using i

Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using i
Σ: Signature
Γ: Theory
x, y: Pattern
xs: list Pattern
i: ProofInfo
wfx: well_formed x
wfy: well_formed y
wfxs: Pattern.wf xs
H: Γ ⊢i x ---> y using i

Γ ⊢i (x ---> y) ---> foldr patt_and x xs ---> foldr patt_and y xs using BasicReasoning
apply foldr_and_weaken_last; assumption. Defined.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern

well_formed x1 → well_formed x2 → Pattern.wf xs → Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern

well_formed x1 → well_formed x2 → Pattern.wf xs → Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf xs

Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf []

Γ ⊢i x1 and x2 <---> x2 and x1 using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf (p :: xs)
Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf []

Γ ⊢i x1 and x2 <---> x2 and x1 using BasicReasoning
apply patt_and_comm; assumption.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs, wfaxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: foldr andb true (map well_formed (p :: xs))
wfaxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfxs: well_formed p && foldr andb true (map well_formed xs)
wfaxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: foldr andb true (map well_formed xs) = true
wfaxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)

well_formed (foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)

well_formed (foldr patt_and (x1 and x2) xs)
apply well_formed_foldr_and;[wf_auto2|assumption].
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)

well_formed (foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)

well_formed (foldr patt_and x1 xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 xs)
apply well_formed_foldr_and; assumption.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ ⊢i p and foldr patt_and x2 (xs ++ [x1]) <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ ⊢i p and foldr patt_and (foldr patt_and x2 [x1]) xs <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ ⊢i p and foldr patt_and (x1 and x2) xs <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

well_formed (p and foldr patt_and (x1 and x2) xs <---> x2 and (p and foldr patt_and x1 xs))
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ p and foldr patt_and (x1 and x2) xs <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

well_formed (p and foldr patt_and (x1 and x2) xs <---> x2 and (p and foldr patt_and x1 xs))
wf_auto2.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ p and foldr patt_and (x1 and x2) xs <---> x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H" ∶ p and foldr patt_and (x1 and x2) xs, -------------------------------------- x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ "H" ∶ x2 and (p and foldr patt_and x1 xs), -------------------------------------- p and foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H" ∶ p and foldr patt_and (x1 and x2) xs, -------------------------------------- x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- x2 and (p and foldr patt_and x1 xs) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- x2 using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- x2 using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ x1 and x2, -------------------------------------- x2 using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hx1" ∶ x1, "Hx2" ∶ x2, -------------------------------------- x2 using BasicReasoning
mlExact "Hx2".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- p using BasicReasoning
mlExact "Ha".
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and ?y xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: Γ ⊢i x1 and x2 ---> ?y using BasicReasoning → Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Γ ⊢i x1 and x2 ---> ?y using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: well_formed ?y → Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
well_formed ?y
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: Γ ⊢i x1 and x2 ---> ?y using BasicReasoning → Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning

Γ ⊢i x1 and x2 ---> ?y using BasicReasoning
apply pf_conj_elim_l; wf_auto2.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and x1 xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
h: well_formed x1 → Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
well_formed x1
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "Ha" ∶ p, "Hf" ∶ foldr patt_and x1 xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
mlExact "Hf". }
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H" ∶ x2 and (p and foldr patt_and x1 xs), -------------------------------------- p and foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H" ∶ x2 and (p and foldr patt_and x1 xs), -------------------------------------- p and foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H1" ∶ x2, "H1'" ∶ p and foldr patt_and x1 xs, -------------------------------------- p and foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, -------------------------------------- p and foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, -------------------------------------- x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)

well_formed (x2 and foldr patt_and x1 xs)
wf_auto2.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)

Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, -------------------------------------- x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)

Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, -------------------------------------- x2 and foldr patt_and x1 xs using BasicReasoning
mlSplitAnd;[mlExact "H1"|mlExact "H3"].
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)

Γ Ⱶ "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)

well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)
Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)
Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, "Hw'" ∶ foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)

well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)
wf_auto2.
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)
Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, "Hw'" ∶ foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, -------------------------------------- x1 ---> x1 and x2 using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, "Hx1" ∶ x1, -------------------------------------- x1 and x2 using BasicReasoning
mlSplitAnd;[mlExact "Hx1"|mlExact "H1"].
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, "Hw'" ∶ foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and (x1 and x2) xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2, p: Pattern
xs: list Pattern
wfx1: well_formed x1
wfx2: well_formed x2
wfa: well_formed p = true
wfxs: Pattern.wf xs = true
wfaxs: Pattern.wf (p :: xs)
Hwf1: well_formed (foldr patt_and (x1 and x2) xs)
Hwf2: well_formed (foldr patt_and x1 xs)
Hwf3: well_formed (foldr patt_and x2 xs)
Hwf: well_formed (x2 and foldr patt_and x1 xs)
Hwf0: well_formed (foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs)

Γ Ⱶ "Hw" ∶ (x1 ---> x1 and x2) ---> foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, "H1" ∶ x2, "H2" ∶ p, "H3" ∶ foldr patt_and x1 xs, "Hf" ∶ x2 and foldr patt_and x1 xs, "Hw'" ∶ foldr patt_and x1 xs ---> foldr patt_and (x1 and x2) xs, -------------------------------------- foldr patt_and x1 xs using BasicReasoning
mlExact "H3". } } Defined.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern

well_formed x1 → well_formed x2 → Pattern.wf xs → Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern

well_formed x1 → well_formed x2 → Pattern.wf xs → Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs

Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs

well_formed (foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs

well_formed (foldr patt_and (x1 and x2) xs)
apply well_formed_foldr_and; wf_auto2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)

Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)

well_formed (foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)

well_formed (foldr patt_and x1 xs)
apply well_formed_foldr_and; wf_auto2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

Γ ⊢i foldr patt_and x2 (xs ++ [x1]) ---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
apply foldr_and_last_rotate; assumption.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and (foldr patt_and x2 [x1]) xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and (x1 and x2) xs)
wf_auto2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (x2 and foldr patt_and x1 xs)
apply well_formed_and; wf_auto2. Defined.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern

well_formed x1 → well_formed x2 → Pattern.wf xs → Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern

well_formed x1 → well_formed x2 → Pattern.wf xs → Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs

Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs

well_formed (foldr patt_and (x1 and x2) xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs

well_formed (foldr patt_and (x1 and x2) xs)
apply well_formed_foldr_and; wf_auto2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)

Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)

well_formed (foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)

well_formed (foldr patt_and x1 xs)
apply well_formed_foldr_and; wf_auto2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

Γ ⊢i x2 and foldr patt_and x1 xs ---> foldr patt_and x2 (xs ++ [x1]) using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

Γ ⊢i foldr patt_and x2 (xs ++ [x1]) <---> x2 and foldr patt_and x1 xs using BasicReasoning
apply foldr_and_last_rotate; assumption.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)
well_formed (x2 and foldr patt_and x1 xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and x2 (xs ++ [x1]))
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and (foldr patt_and x2 [x1]) xs)
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (foldr patt_and (x1 and x2) xs)
wf_auto2.
Σ: Signature
Γ: Theory
x1, x2: Pattern
xs: list Pattern
H: well_formed x1
H0: well_formed x2
H1: Pattern.wf xs
H2: well_formed (foldr patt_and (x1 and x2) xs)
H3: well_formed (foldr patt_and x1 xs)

well_formed (x2 and foldr patt_and x1 xs)
apply well_formed_and; wf_auto2. Defined. #[local] Ltac tryExact l idx := match l with | nil => idtac | (?a :: ?m) => try mlExactn idx; tryExact m (idx + 1) end. #[global] Ltac mlAssumption := _ensureProofMode; (* maybe useless? *) match goal with | [ |- @of_MLGoal ?Sgm (@mkMLGoal ?Sgm ?Ctx ?l ?g ?i) ] => tryExact l 0 end.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i (a ---> b) <---> ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i (a ---> b) <---> ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i (a ---> b) <---> ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed ((a ---> b) <---> ! a or b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ (a ---> b) <---> ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed ((a ---> b) <---> ! a or b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ (a ---> b) <---> ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! ((a ---> b) ---> ! a or b) or ! (! a or b ---> a ---> b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! ((a ---> b) ---> ! a or b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H2" ∶ ! (! a or b ---> a ---> b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! ((a ---> b) ---> ! a or b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ((a ---> b) ---> ! a or b) ---> ⊥, -------------------------------------- (a ---> b) ---> ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ((a ---> b) ---> ! a or b) ---> ⊥, "H2" ∶ a ---> b, -------------------------------------- ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ a ---> b, -------------------------------------- ! a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ a ---> b, "H1" ∶ ! ! a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ a ---> b, "H1" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ a ---> b, "H1" ∶ a, -------------------------------------- a using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! (! a or b ---> a ---> b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (! a or b ---> a ---> b) ---> ⊥, -------------------------------------- ! a or b ---> a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (! a or b ---> a ---> b) ---> ⊥, "H0" ∶ ! a or b, -------------------------------------- a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a or b, -------------------------------------- a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a or b, "H1" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H1" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H3" ∶ b, "H1" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H1" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H1" ∶ a, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ a ---> ⊥, "H1" ∶ a, -------------------------------------- a using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H3" ∶ b, "H1" ∶ a, -------------------------------------- b using BasicReasoning
mlAssumption. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ! (a ---> b) <---> a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ! (a ---> b) <---> a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i ! (a ---> b) <---> a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (! (a ---> b) <---> a and ! b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ ! (a ---> b) <---> a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (! (a ---> b) <---> a and ! b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (a ---> b) <---> a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! (! (a ---> b) ---> a and ! b) or ! (a and ! b ---> ! (a ---> b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! (! (a ---> b) ---> a and ! b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H2" ∶ ! (a and ! b ---> ! (a ---> b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! (! (a ---> b) ---> a and ! b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> a and ! b) ---> ⊥, -------------------------------------- ! (a ---> b) ---> a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> a and ! b) ---> ⊥, "H0" ∶ ! (a ---> b), -------------------------------------- a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ ! (a ---> b), -------------------------------------- ! (! a or ! ! b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ ! (a ---> b), "H2" ∶ ! a or ! ! b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H2" ∶ ! a or ! ! b, -------------------------------------- a ---> b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H2" ∶ ! a or ! ! b, "H3" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H4" ∶ ! a, "H3" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H5" ∶ ! ! b, "H3" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H4" ∶ ! a, "H3" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H4" ∶ ! a, "H3" ∶ a, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H4" ∶ a ---> ⊥, "H3" ∶ a, -------------------------------------- a using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H5" ∶ ! ! b, "H3" ∶ a, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ (! (a ---> b) ---> ! (! a or ! ! b)) ---> ⊥, "H0" ∶ (a ---> b) ---> ⊥, "H5" ∶ b, "H3" ∶ a, -------------------------------------- b using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! (a and ! b ---> ! (a ---> b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥, -------------------------------------- a and ! b ---> ! (a ---> b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥, "H0" ∶ a and ! b, -------------------------------------- ! (a ---> b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥, "H0" ∶ a and ! b, "H1" ∶ a ---> b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥, "H3" ∶ a, "H4" ∶ ! b, "H1" ∶ a ---> b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥, "H3" ∶ a, "H4" ∶ b ---> ⊥, "H1" ∶ a ---> b, -------------------------------------- b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ (a and ! b ---> ! (a ---> b)) ---> ⊥, "H3" ∶ a, "H4" ∶ b ---> ⊥, "H1" ∶ a ---> b, -------------------------------------- a using BasicReasoning
mlAssumption. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ! (a and b) <---> ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ! (a and b) <---> ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i ! (a and b) <---> ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (! (a and b) <---> ! a or ! b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ ! (a and b) <---> ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (! (a and b) <---> ! a or ! b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (a and b) <---> ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! (! (a and b) ---> ! a or ! b) or ! (! a or ! b ---> ! (a and b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! (! (a and b) ---> ! a or ! b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H2" ∶ ! (! a or ! b ---> ! (a and b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! (! (a and b) ---> ! a or ! b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (! (a and b) ---> ! a or ! b) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (a and b) ---> ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! (a and b), -------------------------------------- ! a or ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a or ! b, -------------------------------------- ! a or ! b using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! (! a or ! b ---> ! (a and b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (! a or ! b ---> ! (a and b)) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! a or ! b ---> ! (a and b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a or ! b, -------------------------------------- ! (a and b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a or ! b, -------------------------------------- ! a or ! b using BasicReasoning
mlAssumption. Defined.
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ! (a or b) <---> ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern

well_formed a → well_formed b → Γ ⊢i ! (a or b) <---> ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ ⊢i ! (a or b) <---> ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (! (a or b) <---> ! a and ! b)
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ ! (a or b) <---> ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

well_formed (! (a or b) <---> ! a and ! b)
wf_auto2.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (a or b) <---> ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! (! (a or b) ---> ! a and ! b) or ! (! a and ! b ---> ! (a or b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! (! (a or b) ---> ! a and ! b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H2" ∶ ! (! a and ! b ---> ! (a or b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H1" ∶ ! (! (a or b) ---> ! a and ! b), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (! (a or b) ---> ! a and ! b) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (a or b) ---> ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! (a or b), -------------------------------------- ! a and ! b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! (a or b), "H1" ∶ ! ! a or ! ! b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H1" ∶ ! ! a or ! ! b, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H2" ∶ ! ! a, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H3" ∶ ! ! b, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H2" ∶ ! ! a, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H2" ∶ a, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H2" ∶ a, -------------------------------------- a using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H3" ∶ ! ! b, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H3" ∶ b, -------------------------------------- a or b using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ a or b ---> ⊥, "H3" ∶ b, -------------------------------------- b using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! (! a and ! b ---> ! (a or b)), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! (! a and ! b ---> ! (a or b)) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ ! a and ! b ---> ! (a or b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a and ! b, -------------------------------------- ! (a or b) using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H0" ∶ ! a and ! b, "H1" ∶ a or b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H3" ∶ ! b, "H1" ∶ a or b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H3" ∶ ! b, "H4" ∶ a, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b
Γ Ⱶ "H2" ∶ ! a, "H3" ∶ ! b, "H5" ∶ b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H3" ∶ ! b, "H4" ∶ a, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ a ---> ⊥, "H3" ∶ ! b, "H4" ∶ a, -------------------------------------- a using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H3" ∶ ! b, "H5" ∶ b, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a, b: Pattern
wfa: well_formed a
wfb: well_formed b

Γ Ⱶ "H2" ∶ ! a, "H3" ∶ b ---> ⊥, "H5" ∶ b, -------------------------------------- b using BasicReasoning
mlAssumption. Defined.
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i ! ! a <---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern

well_formed a → Γ ⊢i ! ! a <---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ ⊢i ! ! a <---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (! ! a <---> a)
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ ! ! a <---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

well_formed (! ! a <---> a)
wf_auto2.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ ! ! a <---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H0" ∶ ! (! ! a ---> a) or ! (a ---> ! ! a), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H1" ∶ ! (! ! a ---> a), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a
Γ Ⱶ "H2" ∶ ! (a ---> ! ! a), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H1" ∶ ! (! ! a ---> a), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H1" ∶ (! ! a ---> a) ---> ⊥, -------------------------------------- ! ! a ---> a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H1" ∶ (! ! a ---> a) ---> ⊥, "H0" ∶ ! ! a, -------------------------------------- a using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H1" ∶ (! ! a ---> a) ---> ⊥, "H0" ∶ a, -------------------------------------- a using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H2" ∶ ! (a ---> ! ! a), -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥, -------------------------------------- a ---> (a ---> ⊥) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥, "H0" ∶ a, -------------------------------------- (a ---> ⊥) ---> ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥, "H0" ∶ a, "H1" ∶ a ---> ⊥, -------------------------------------- ⊥ using BasicReasoning
Σ: Signature
Γ: Theory
a: Pattern
wfa: well_formed a

Γ Ⱶ "H2" ∶ (a ---> (a ---> ⊥) ---> ⊥) ---> ⊥, "H0" ∶ a, "H1" ∶ a ---> ⊥, -------------------------------------- a using BasicReasoning
mlAssumption. Defined.
Σ: Signature

(Γ : Theory) (p : Pattern), well_formed p → Γ ⊢i p and p <---> p using BasicReasoning
Σ: Signature

(Γ : Theory) (p : Pattern), well_formed p → Γ ⊢i p and p <---> p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

Γ ⊢i p and p <---> p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

well_formed (p and p <---> p)
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ p and p <---> p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

Γ Ⱶ p and p <---> p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

Γ Ⱶ "H" ∶ p and p, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p
Γ Ⱶ "H" ∶ p, -------------------------------------- p and p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

Γ Ⱶ "H" ∶ p and p, -------------------------------------- p using BasicReasoning
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

Γ Ⱶ "0" ∶ p, "1" ∶ p, -------------------------------------- p using BasicReasoning
mlAssumption.
Σ: Signature
Γ: Theory
p: Pattern
WFp: well_formed p

Γ Ⱶ "H" ∶ p, -------------------------------------- p and p using BasicReasoning
mlSplitAnd; mlAssumption. Defined.
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢ ⊥ and ϕ <---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢ ⊥ and ϕ <---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢ ⊥ and ϕ <---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (⊥ and ϕ <---> ⊥)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ ⊥ and ϕ <---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (⊥ and ϕ <---> ⊥)
wf_auto2.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ⊥ and ϕ <---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ⊥ and ϕ ---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ ⊥ ---> ⊥ and ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ⊥ and ϕ ---> ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ⊥ and ϕ, -------------------------------------- ⊥
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "B" ∶ ⊥, "P" ∶ ϕ, -------------------------------------- ⊥
mlExact "B".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ⊥ ---> ⊥ and ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ⊥, -------------------------------------- ⊥ and ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ⊥, -------------------------------------- ⊥
mlExact "H". Defined.
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢ Top and ϕ <---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern

well_formed ϕ → Γ ⊢ Top and ϕ <---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢ Top and ϕ <---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (Top and ϕ <---> ϕ)
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ Top and ϕ <---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

well_formed (Top and ϕ <---> ϕ)
wf_auto2.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ Top and ϕ <---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ Top and ϕ ---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ ϕ ---> Top and ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ Top and ϕ ---> ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ Top and ϕ, -------------------------------------- ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "T" ∶ Top, "P" ∶ ϕ, -------------------------------------- ϕ
mlExact "P".
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ ϕ ---> Top and ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ϕ, -------------------------------------- Top and ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ϕ, -------------------------------------- Top
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ
Γ Ⱶ "H" ∶ ϕ, -------------------------------------- ϕ
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ϕ, -------------------------------------- Top
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ Top
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ ⊢i Top using AnyReasoning
aapply top_holds.
Σ: Signature
Γ: Theory
ϕ: Pattern
wfϕ: well_formed ϕ

Γ Ⱶ "H" ∶ ϕ, -------------------------------------- ϕ
mlExact "H". Defined.
Σ: Signature

(Γ : Theory) (l : hypotheses) (g : Pattern) (i : ProofInfo), Γ ⊢i g using i → Γ Ⱶ l-------------------------------------- g using i
Σ: Signature

(Γ : Theory) (l : hypotheses) (g : Pattern) (i : ProofInfo), Γ ⊢i g using i → Γ Ⱶ l-------------------------------------- g using i
Σ: Signature
Γ: Theory
l: hypotheses
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- g using i ))
wfl: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i )))

mlTheory (Γ Ⱶ l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- g using i )
Σ: Signature
Γ: Theory
l: hypotheses
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed (mlConclusion (Γ Ⱶ l-------------------------------------- g using i ))
wfl: Pattern.wf (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i )))

mlTheory (Γ Ⱶ l-------------------------------------- g using i ) ⊢i foldr patt_imp (mlConclusion (Γ Ⱶ l-------------------------------------- g using i )) (patterns_of (mlHypotheses (Γ Ⱶ l-------------------------------------- g using i ))) using mlInfo (Γ Ⱶ l-------------------------------------- g using i )
Σ: Signature
Γ: Theory
l: hypotheses
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (patterns_of l)

Γ ⊢i foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (patterns_of (a :: l))
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i

Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (nh_patt a :: patterns_of l)
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i

Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: Pattern.wf (nh_patt a :: patterns_of l)
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true

Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: well_formed (nh_patt a) && foldr andb true (map well_formed (patterns_of l))
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true

Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: well_formed (nh_patt a) = true
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true

Γ ⊢i nh_patt a ---> foldr patt_imp g (patterns_of l) using i
Σ: Signature
Γ: Theory
a: named_hypothesis
l: list named_hypothesis
g: Pattern
i: ProofInfo
pf: Γ ⊢i g using i
wfG: well_formed g
wfl: well_formed (nh_patt a) = true
IHl: Pattern.wf (patterns_of l) → Γ ⊢i foldr patt_imp g (patterns_of l) using i
wfl': Pattern.wf (patterns_of l) = true

Γ ⊢i foldr patt_imp g (patterns_of l) using i
auto with nocore. Defined. Tactic Notation "mlExactMeta" uconstr(t) := _ensureProofMode; apply (@MLGoal_ExactMeta _ _ _ _ _ t).

(Σ : Signature) (Γ : Theory), Γ ⊢i Top using BasicReasoning

(Σ : Signature) (Γ : Theory), Γ ⊢i Top using BasicReasoning
Σ: Signature
Γ: Theory

Γ ⊢i Top using BasicReasoning
Σ: Signature
Γ: Theory

well_formed Top
Σ: Signature
Γ: Theory
Γ Ⱶ Top using BasicReasoning
Σ: Signature
Γ: Theory

Γ Ⱶ Top using BasicReasoning
mlExactMeta (top_holds Γ). Defined.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo

well_formed p → Γ ⊢i p and ! p ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo

well_formed p → Γ ⊢i p and ! p ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ ⊢i p and ! p ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

well_formed (p and ! p ---> Top)
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ p and ! p ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

well_formed (p and ! p ---> Top)
wf_auto2.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ p and ! p ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ "H" ∶ p and ! p, -------------------------------------- Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ "H0" ∶ p, "H1" ∶ ! p, -------------------------------------- Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ "H0" ∶ p, "H1" ∶ ! p, -------------------------------------- ⊥ using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ "H0" ∶ p, "H1" ∶ p ---> ⊥, -------------------------------------- p using i
mlExact "H0". Defined.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo

well_formed p → Γ ⊢i ⊥ ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo

well_formed p → Γ ⊢i ⊥ ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ ⊢i ⊥ ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

well_formed (⊥ ---> Top)
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p
Γ Ⱶ ⊥ ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

well_formed (⊥ ---> Top)
wf_auto2.
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ ⊥ ---> Top using i
Σ: Signature
p: Pattern
Γ: Theory
i: ProofInfo
WF: well_formed p

Γ Ⱶ "H" ∶ ⊥, -------------------------------------- Top using i
mlDestructBot "H". Defined. (**********************************************************************************) (* This is an example and belongs to the end of this file. Its only purpose is only to show as many tactics as possible.\ *)
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p and q <---> p' and q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p and q <---> p' and q')
wf_auto2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p and q <---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ (p and q ---> p' and q') and (p' and q' ---> p and q) using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p' and q' ---> p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p and q ---> p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p and q, -------------------------------------- p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- p' and q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- p using i
mlExactn 0.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, "H2" ∶ q, -------------------------------------- q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, "H2" ∶ q', -------------------------------------- q' using i
mlExact "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p' and q' ---> p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', -------------------------------------- p and q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', -------------------------------------- ! (! p or ! q) using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', -------------------------------------- ! p or ! q ---> ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', "H1" ∶ ! p or ! q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', "H2" ∶ ! p, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H0" ∶ p' and q', "H3" ∶ ! q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', "H2" ∶ ! p, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H3" ∶ p', "H4" ∶ q', "H2" ∶ ! p, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H3" ∶ p', "H4" ∶ q', "H2" ∶ p ---> ⊥, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H3" ∶ p', "H4" ∶ q', "H2" ∶ p ---> ⊥, -------------------------------------- p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H3" ∶ p', "H4" ∶ q', -------------------------------------- p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H3" ∶ p', -------------------------------------- p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p' ---> p using i
exact p'ip.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' and q', "H3" ∶ ! q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ q' ---> q, "H0" ∶ p' and q', "H3" ∶ ! q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed q
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, -------------------------------------- q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, "Hq" ∶ q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed q
wf_auto2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, -------------------------------------- q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q
Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, "Hq" ∶ q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, -------------------------------------- q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, -------------------------------------- q' using i
mlExact "H4".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ ! q, "Hq" ∶ q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ q ---> ⊥, "Hq" ∶ q, -------------------------------------- ⊥ using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Hwf: well_formed q

Γ Ⱶ "H1" ∶ q' ---> q, "H2" ∶ p', "H4" ∶ q', "H3" ∶ q ---> ⊥, "Hq" ∶ q, -------------------------------------- q using i
mlAssumption. Defined.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo

well_formed p → well_formed q → well_formed p' → well_formed q' → Γ ⊢i p <---> p' using i → Γ ⊢i q <---> q' using i → Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p <---> p' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p <---> p' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q <---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q <---> q' using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ ⊢i p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p or q <---> p' or q')
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

well_formed (p or q <---> p' or q')
wf_auto2.
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p or q <---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ (p or q ---> p' or q') and (p' or q' ---> p or q) using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ p' or q' ---> p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p or q ---> p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p or q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H2" ∶ q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H2" ∶ q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p, -------------------------------------- p using i
mlExact "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q, -------------------------------------- p' or q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q, -------------------------------------- q' using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q, -------------------------------------- q using i
mlExact "H2".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ p' or q' ---> p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H0" ∶ p' or q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H2" ∶ q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i
Γ Ⱶ "H2" ∶ q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H1" ∶ p', -------------------------------------- p' using i
mlExact "H1".
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q', -------------------------------------- p or q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q', -------------------------------------- q using i
Σ: Signature
Γ: Theory
p, q, p', q': Pattern
i: ProofInfo
wfp: well_formed p
wfq: well_formed q
wfp': well_formed p'
wfq': well_formed q'
pep': Γ ⊢i p <---> p' using i
qeq': Γ ⊢i q <---> q' using i
pip': Γ ⊢i p ---> p' using i
p'ip: Γ ⊢i p' ---> p using i
qiq': Γ ⊢i q ---> q' using i
q'iq: Γ ⊢i q' ---> q using i

Γ Ⱶ "H2" ∶ q', -------------------------------------- q' using i
mlExact "H2". Defined. Close Scope string_scope. Close Scope list_scope. Close Scope ml_scope.